1
2
3
4
5
6
7
8
9
10#ifndef _LINUX_I2C_H
11#define _LINUX_I2C_H
12
13#include <linux/acpi.h>
14#include <linux/mod_devicetable.h>
15#include <linux/device.h>
16#include <linux/sched.h>
17#include <linux/mutex.h>
18#include <linux/regulator/consumer.h>
19#include <linux/rtmutex.h>
20#include <linux/irqdomain.h>
21#include <linux/of.h>
22#include <linux/swab.h>
23#include <uapi/linux/i2c.h>
24
25extern struct bus_type i2c_bus_type;
26extern struct device_type i2c_adapter_type;
27extern struct device_type i2c_client_type;
28
29
30
31struct i2c_msg;
32struct i2c_algorithm;
33struct i2c_adapter;
34struct i2c_client;
35struct i2c_driver;
36struct i2c_device_identity;
37union i2c_smbus_data;
38struct i2c_board_info;
39enum i2c_slave_event;
40typedef int (*i2c_slave_cb_t)(struct i2c_client *client,
41 enum i2c_slave_event event, u8 *val);
42
43
44#define I2C_MAX_STANDARD_MODE_FREQ 100000
45#define I2C_MAX_FAST_MODE_FREQ 400000
46#define I2C_MAX_FAST_MODE_PLUS_FREQ 1000000
47#define I2C_MAX_TURBO_MODE_FREQ 1400000
48#define I2C_MAX_HIGH_SPEED_MODE_FREQ 3400000
49#define I2C_MAX_ULTRA_FAST_MODE_FREQ 5000000
50
51struct module;
52struct property_entry;
53
54#if IS_ENABLED(CONFIG_I2C)
55
56const char *i2c_freq_mode_string(u32 bus_freq_hz);
57
58
59
60
61
62
63
64
65int i2c_transfer_buffer_flags(const struct i2c_client *client,
66 char *buf, int count, u16 flags);
67
68
69
70
71
72
73
74
75
76static inline int i2c_master_recv(const struct i2c_client *client,
77 char *buf, int count)
78{
79 return i2c_transfer_buffer_flags(client, buf, count, I2C_M_RD);
80};
81
82
83
84
85
86
87
88
89
90
91static inline int i2c_master_recv_dmasafe(const struct i2c_client *client,
92 char *buf, int count)
93{
94 return i2c_transfer_buffer_flags(client, buf, count,
95 I2C_M_RD | I2C_M_DMA_SAFE);
96};
97
98
99
100
101
102
103
104
105
106static inline int i2c_master_send(const struct i2c_client *client,
107 const char *buf, int count)
108{
109 return i2c_transfer_buffer_flags(client, (char *)buf, count, 0);
110};
111
112
113
114
115
116
117
118
119
120
121static inline int i2c_master_send_dmasafe(const struct i2c_client *client,
122 const char *buf, int count)
123{
124 return i2c_transfer_buffer_flags(client, (char *)buf, count,
125 I2C_M_DMA_SAFE);
126};
127
128
129
130int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num);
131
132int __i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num);
133
134
135
136
137
138
139s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr,
140 unsigned short flags, char read_write, u8 command,
141 int protocol, union i2c_smbus_data *data);
142
143
144s32 __i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr,
145 unsigned short flags, char read_write, u8 command,
146 int protocol, union i2c_smbus_data *data);
147
148
149
150
151u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count);
152s32 i2c_smbus_read_byte(const struct i2c_client *client);
153s32 i2c_smbus_write_byte(const struct i2c_client *client, u8 value);
154s32 i2c_smbus_read_byte_data(const struct i2c_client *client, u8 command);
155s32 i2c_smbus_write_byte_data(const struct i2c_client *client,
156 u8 command, u8 value);
157s32 i2c_smbus_read_word_data(const struct i2c_client *client, u8 command);
158s32 i2c_smbus_write_word_data(const struct i2c_client *client,
159 u8 command, u16 value);
160
161static inline s32
162i2c_smbus_read_word_swapped(const struct i2c_client *client, u8 command)
163{
164 s32 value = i2c_smbus_read_word_data(client, command);
165
166 return (value < 0) ? value : swab16(value);
167}
168
169static inline s32
170i2c_smbus_write_word_swapped(const struct i2c_client *client,
171 u8 command, u16 value)
172{
173 return i2c_smbus_write_word_data(client, command, swab16(value));
174}
175
176
177s32 i2c_smbus_read_block_data(const struct i2c_client *client,
178 u8 command, u8 *values);
179s32 i2c_smbus_write_block_data(const struct i2c_client *client,
180 u8 command, u8 length, const u8 *values);
181
182s32 i2c_smbus_read_i2c_block_data(const struct i2c_client *client,
183 u8 command, u8 length, u8 *values);
184s32 i2c_smbus_write_i2c_block_data(const struct i2c_client *client,
185 u8 command, u8 length, const u8 *values);
186s32 i2c_smbus_read_i2c_block_data_or_emulated(const struct i2c_client *client,
187 u8 command, u8 length,
188 u8 *values);
189int i2c_get_device_id(const struct i2c_client *client,
190 struct i2c_device_identity *id);
191#endif
192
193
194
195
196
197
198
199struct i2c_device_identity {
200 u16 manufacturer_id;
201#define I2C_DEVICE_ID_NXP_SEMICONDUCTORS 0
202#define I2C_DEVICE_ID_NXP_SEMICONDUCTORS_1 1
203#define I2C_DEVICE_ID_NXP_SEMICONDUCTORS_2 2
204#define I2C_DEVICE_ID_NXP_SEMICONDUCTORS_3 3
205#define I2C_DEVICE_ID_RAMTRON_INTERNATIONAL 4
206#define I2C_DEVICE_ID_ANALOG_DEVICES 5
207#define I2C_DEVICE_ID_STMICROELECTRONICS 6
208#define I2C_DEVICE_ID_ON_SEMICONDUCTOR 7
209#define I2C_DEVICE_ID_SPRINTEK_CORPORATION 8
210#define I2C_DEVICE_ID_ESPROS_PHOTONICS_AG 9
211#define I2C_DEVICE_ID_FUJITSU_SEMICONDUCTOR 10
212#define I2C_DEVICE_ID_FLIR 11
213#define I2C_DEVICE_ID_O2MICRO 12
214#define I2C_DEVICE_ID_ATMEL 13
215#define I2C_DEVICE_ID_NONE 0xffff
216 u16 part_id;
217 u8 die_revision;
218};
219
220enum i2c_alert_protocol {
221 I2C_PROTOCOL_SMBUS_ALERT,
222 I2C_PROTOCOL_SMBUS_HOST_NOTIFY,
223};
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260struct i2c_driver {
261 unsigned int class;
262
263
264 int (*probe)(struct i2c_client *client, const struct i2c_device_id *id);
265 int (*remove)(struct i2c_client *client);
266
267
268
269
270 int (*probe_new)(struct i2c_client *client);
271
272
273 void (*shutdown)(struct i2c_client *client);
274
275
276
277
278
279
280
281
282 void (*alert)(struct i2c_client *client, enum i2c_alert_protocol protocol,
283 unsigned int data);
284
285
286
287
288 int (*command)(struct i2c_client *client, unsigned int cmd, void *arg);
289
290 struct device_driver driver;
291 const struct i2c_device_id *id_table;
292
293
294 int (*detect)(struct i2c_client *client, struct i2c_board_info *info);
295 const unsigned short *address_list;
296 struct list_head clients;
297};
298#define to_i2c_driver(d) container_of(d, struct i2c_driver, driver)
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321struct i2c_client {
322 unsigned short flags;
323#define I2C_CLIENT_PEC 0x04
324#define I2C_CLIENT_TEN 0x10
325
326#define I2C_CLIENT_SLAVE 0x20
327#define I2C_CLIENT_HOST_NOTIFY 0x40
328#define I2C_CLIENT_WAKE 0x80
329#define I2C_CLIENT_SCCB 0x9000
330
331
332 unsigned short addr;
333
334
335 char name[I2C_NAME_SIZE];
336 struct i2c_adapter *adapter;
337 struct device dev;
338 int init_irq;
339 int irq;
340 struct list_head detected;
341#if IS_ENABLED(CONFIG_I2C_SLAVE)
342 i2c_slave_cb_t slave_cb;
343#endif
344 void *devres_group_id;
345};
346#define to_i2c_client(d) container_of(d, struct i2c_client, dev)
347
348struct i2c_adapter *i2c_verify_adapter(struct device *dev);
349const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id,
350 const struct i2c_client *client);
351
352static inline struct i2c_client *kobj_to_i2c_client(struct kobject *kobj)
353{
354 struct device * const dev = kobj_to_dev(kobj);
355 return to_i2c_client(dev);
356}
357
358static inline void *i2c_get_clientdata(const struct i2c_client *client)
359{
360 return dev_get_drvdata(&client->dev);
361}
362
363static inline void i2c_set_clientdata(struct i2c_client *client, void *data)
364{
365 dev_set_drvdata(&client->dev, data);
366}
367
368
369
370#if IS_ENABLED(CONFIG_I2C_SLAVE)
371enum i2c_slave_event {
372 I2C_SLAVE_READ_REQUESTED,
373 I2C_SLAVE_WRITE_REQUESTED,
374 I2C_SLAVE_READ_PROCESSED,
375 I2C_SLAVE_WRITE_RECEIVED,
376 I2C_SLAVE_STOP,
377};
378
379int i2c_slave_register(struct i2c_client *client, i2c_slave_cb_t slave_cb);
380int i2c_slave_unregister(struct i2c_client *client);
381bool i2c_detect_slave_mode(struct device *dev);
382
383static inline int i2c_slave_event(struct i2c_client *client,
384 enum i2c_slave_event event, u8 *val)
385{
386 return client->slave_cb(client, event, val);
387}
388#else
389static inline bool i2c_detect_slave_mode(struct device *dev) { return false; }
390#endif
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417struct i2c_board_info {
418 char type[I2C_NAME_SIZE];
419 unsigned short flags;
420 unsigned short addr;
421 const char *dev_name;
422 void *platform_data;
423 struct device_node *of_node;
424 struct fwnode_handle *fwnode;
425 const struct software_node *swnode;
426 const struct resource *resources;
427 unsigned int num_resources;
428 int irq;
429};
430
431
432
433
434
435
436
437
438
439
440
441#define I2C_BOARD_INFO(dev_type, dev_addr) \
442 .type = dev_type, .addr = (dev_addr)
443
444
445#if IS_ENABLED(CONFIG_I2C)
446
447
448
449
450
451struct i2c_client *
452i2c_new_client_device(struct i2c_adapter *adap, struct i2c_board_info const *info);
453
454
455
456
457
458
459
460struct i2c_client *
461i2c_new_scanned_device(struct i2c_adapter *adap,
462 struct i2c_board_info *info,
463 unsigned short const *addr_list,
464 int (*probe)(struct i2c_adapter *adap, unsigned short addr));
465
466
467int i2c_probe_func_quick_read(struct i2c_adapter *adap, unsigned short addr);
468
469struct i2c_client *
470i2c_new_dummy_device(struct i2c_adapter *adapter, u16 address);
471
472struct i2c_client *
473devm_i2c_new_dummy_device(struct device *dev, struct i2c_adapter *adap, u16 address);
474
475struct i2c_client *
476i2c_new_ancillary_device(struct i2c_client *client,
477 const char *name,
478 u16 default_addr);
479
480void i2c_unregister_device(struct i2c_client *client);
481
482struct i2c_client *i2c_verify_client(struct device *dev);
483#else
484static inline struct i2c_client *i2c_verify_client(struct device *dev)
485{
486 return NULL;
487}
488#endif
489
490
491
492
493
494#ifdef CONFIG_I2C_BOARDINFO
495int
496i2c_register_board_info(int busnum, struct i2c_board_info const *info,
497 unsigned n);
498#else
499static inline int
500i2c_register_board_info(int busnum, struct i2c_board_info const *info,
501 unsigned n)
502{
503 return 0;
504}
505#endif
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533struct i2c_algorithm {
534
535
536
537
538
539
540
541
542
543 int (*master_xfer)(struct i2c_adapter *adap, struct i2c_msg *msgs,
544 int num);
545 int (*master_xfer_atomic)(struct i2c_adapter *adap,
546 struct i2c_msg *msgs, int num);
547 int (*smbus_xfer)(struct i2c_adapter *adap, u16 addr,
548 unsigned short flags, char read_write,
549 u8 command, int size, union i2c_smbus_data *data);
550 int (*smbus_xfer_atomic)(struct i2c_adapter *adap, u16 addr,
551 unsigned short flags, char read_write,
552 u8 command, int size, union i2c_smbus_data *data);
553
554
555 u32 (*functionality)(struct i2c_adapter *adap);
556
557#if IS_ENABLED(CONFIG_I2C_SLAVE)
558 int (*reg_slave)(struct i2c_client *client);
559 int (*unreg_slave)(struct i2c_client *client);
560#endif
561};
562
563
564
565
566
567
568
569
570
571struct i2c_lock_operations {
572 void (*lock_bus)(struct i2c_adapter *adapter, unsigned int flags);
573 int (*trylock_bus)(struct i2c_adapter *adapter, unsigned int flags);
574 void (*unlock_bus)(struct i2c_adapter *adapter, unsigned int flags);
575};
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590struct i2c_timings {
591 u32 bus_freq_hz;
592 u32 scl_rise_ns;
593 u32 scl_fall_ns;
594 u32 scl_int_delay_ns;
595 u32 sda_fall_ns;
596 u32 sda_hold_ns;
597 u32 digital_filter_width_ns;
598 u32 analog_filter_cutoff_freq_hz;
599};
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632struct i2c_bus_recovery_info {
633 int (*recover_bus)(struct i2c_adapter *adap);
634
635 int (*get_scl)(struct i2c_adapter *adap);
636 void (*set_scl)(struct i2c_adapter *adap, int val);
637 int (*get_sda)(struct i2c_adapter *adap);
638 void (*set_sda)(struct i2c_adapter *adap, int val);
639 int (*get_bus_free)(struct i2c_adapter *adap);
640
641 void (*prepare_recovery)(struct i2c_adapter *adap);
642 void (*unprepare_recovery)(struct i2c_adapter *adap);
643
644
645 struct gpio_desc *scl_gpiod;
646 struct gpio_desc *sda_gpiod;
647 struct pinctrl *pinctrl;
648 struct pinctrl_state *pins_default;
649 struct pinctrl_state *pins_gpio;
650};
651
652int i2c_recover_bus(struct i2c_adapter *adap);
653
654
655int i2c_generic_scl_recovery(struct i2c_adapter *adap);
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678struct i2c_adapter_quirks {
679 u64 flags;
680 int max_num_msgs;
681 u16 max_write_len;
682 u16 max_read_len;
683 u16 max_comb_1st_msg_len;
684 u16 max_comb_2nd_msg_len;
685};
686
687
688#define I2C_AQ_COMB BIT(0)
689
690#define I2C_AQ_COMB_WRITE_FIRST BIT(1)
691
692#define I2C_AQ_COMB_READ_SECOND BIT(2)
693
694#define I2C_AQ_COMB_SAME_ADDR BIT(3)
695
696#define I2C_AQ_COMB_WRITE_THEN_READ (I2C_AQ_COMB | I2C_AQ_COMB_WRITE_FIRST | \
697 I2C_AQ_COMB_READ_SECOND | I2C_AQ_COMB_SAME_ADDR)
698
699#define I2C_AQ_NO_CLK_STRETCH BIT(4)
700
701#define I2C_AQ_NO_ZERO_LEN_READ BIT(5)
702#define I2C_AQ_NO_ZERO_LEN_WRITE BIT(6)
703#define I2C_AQ_NO_ZERO_LEN (I2C_AQ_NO_ZERO_LEN_READ | I2C_AQ_NO_ZERO_LEN_WRITE)
704
705#define I2C_AQ_NO_REP_START BIT(7)
706
707
708
709
710
711struct i2c_adapter {
712 struct module *owner;
713 unsigned int class;
714 const struct i2c_algorithm *algo;
715 void *algo_data;
716
717
718 const struct i2c_lock_operations *lock_ops;
719 struct rt_mutex bus_lock;
720 struct rt_mutex mux_lock;
721
722 int timeout;
723 int retries;
724 struct device dev;
725 unsigned long locked_flags;
726#define I2C_ALF_IS_SUSPENDED 0
727#define I2C_ALF_SUSPEND_REPORTED 1
728
729 int nr;
730 char name[48];
731 struct completion dev_released;
732
733 struct mutex userspace_clients_lock;
734 struct list_head userspace_clients;
735
736 struct i2c_bus_recovery_info *bus_recovery_info;
737 const struct i2c_adapter_quirks *quirks;
738
739 struct irq_domain *host_notify_domain;
740 struct regulator *bus_regulator;
741};
742#define to_i2c_adapter(d) container_of(d, struct i2c_adapter, dev)
743
744static inline void *i2c_get_adapdata(const struct i2c_adapter *adap)
745{
746 return dev_get_drvdata(&adap->dev);
747}
748
749static inline void i2c_set_adapdata(struct i2c_adapter *adap, void *data)
750{
751 dev_set_drvdata(&adap->dev, data);
752}
753
754static inline struct i2c_adapter *
755i2c_parent_is_i2c_adapter(const struct i2c_adapter *adapter)
756{
757#if IS_ENABLED(CONFIG_I2C_MUX)
758 struct device *parent = adapter->dev.parent;
759
760 if (parent != NULL && parent->type == &i2c_adapter_type)
761 return to_i2c_adapter(parent);
762 else
763#endif
764 return NULL;
765}
766
767int i2c_for_each_dev(void *data, int (*fn)(struct device *dev, void *data));
768
769
770#define I2C_LOCK_ROOT_ADAPTER BIT(0)
771#define I2C_LOCK_SEGMENT BIT(1)
772
773
774
775
776
777
778
779static inline void
780i2c_lock_bus(struct i2c_adapter *adapter, unsigned int flags)
781{
782 adapter->lock_ops->lock_bus(adapter, flags);
783}
784
785
786
787
788
789
790
791
792
793static inline int
794i2c_trylock_bus(struct i2c_adapter *adapter, unsigned int flags)
795{
796 return adapter->lock_ops->trylock_bus(adapter, flags);
797}
798
799
800
801
802
803
804
805static inline void
806i2c_unlock_bus(struct i2c_adapter *adapter, unsigned int flags)
807{
808 adapter->lock_ops->unlock_bus(adapter, flags);
809}
810
811
812
813
814
815
816
817
818
819
820
821static inline void i2c_mark_adapter_suspended(struct i2c_adapter *adap)
822{
823 i2c_lock_bus(adap, I2C_LOCK_ROOT_ADAPTER);
824 set_bit(I2C_ALF_IS_SUSPENDED, &adap->locked_flags);
825 i2c_unlock_bus(adap, I2C_LOCK_ROOT_ADAPTER);
826}
827
828
829
830
831
832
833
834
835
836static inline void i2c_mark_adapter_resumed(struct i2c_adapter *adap)
837{
838 i2c_lock_bus(adap, I2C_LOCK_ROOT_ADAPTER);
839 clear_bit(I2C_ALF_IS_SUSPENDED, &adap->locked_flags);
840 i2c_unlock_bus(adap, I2C_LOCK_ROOT_ADAPTER);
841}
842
843
844#define I2C_CLASS_HWMON (1<<0)
845#define I2C_CLASS_DDC (1<<3)
846#define I2C_CLASS_SPD (1<<7)
847
848#define I2C_CLASS_DEPRECATED (1<<8)
849
850
851#define I2C_CLIENT_END 0xfffeU
852
853
854#define I2C_ADDRS(addr, addrs...) \
855 ((const unsigned short []){ addr, ## addrs, I2C_CLIENT_END })
856
857
858
859
860
861
862#if IS_ENABLED(CONFIG_I2C)
863int i2c_add_adapter(struct i2c_adapter *adap);
864int devm_i2c_add_adapter(struct device *dev, struct i2c_adapter *adapter);
865void i2c_del_adapter(struct i2c_adapter *adap);
866int i2c_add_numbered_adapter(struct i2c_adapter *adap);
867
868int i2c_register_driver(struct module *owner, struct i2c_driver *driver);
869void i2c_del_driver(struct i2c_driver *driver);
870
871
872#define i2c_add_driver(driver) \
873 i2c_register_driver(THIS_MODULE, driver)
874
875static inline bool i2c_client_has_driver(struct i2c_client *client)
876{
877 return !IS_ERR_OR_NULL(client) && client->dev.driver;
878}
879
880
881
882void i2c_clients_command(struct i2c_adapter *adap,
883 unsigned int cmd, void *arg);
884
885struct i2c_adapter *i2c_get_adapter(int nr);
886void i2c_put_adapter(struct i2c_adapter *adap);
887unsigned int i2c_adapter_depth(struct i2c_adapter *adapter);
888
889void i2c_parse_fw_timings(struct device *dev, struct i2c_timings *t, bool use_defaults);
890
891
892static inline u32 i2c_get_functionality(struct i2c_adapter *adap)
893{
894 return adap->algo->functionality(adap);
895}
896
897
898static inline int i2c_check_functionality(struct i2c_adapter *adap, u32 func)
899{
900 return (func & i2c_get_functionality(adap)) == func;
901}
902
903
904
905
906
907
908
909
910static inline bool i2c_check_quirks(struct i2c_adapter *adap, u64 quirks)
911{
912 if (!adap->quirks)
913 return false;
914 return (adap->quirks->flags & quirks) == quirks;
915}
916
917
918static inline int i2c_adapter_id(struct i2c_adapter *adap)
919{
920 return adap->nr;
921}
922
923static inline u8 i2c_8bit_addr_from_msg(const struct i2c_msg *msg)
924{
925 return (msg->addr << 1) | (msg->flags & I2C_M_RD ? 1 : 0);
926}
927
928u8 *i2c_get_dma_safe_msg_buf(struct i2c_msg *msg, unsigned int threshold);
929void i2c_put_dma_safe_msg_buf(u8 *buf, struct i2c_msg *msg, bool xferred);
930
931int i2c_handle_smbus_host_notify(struct i2c_adapter *adap, unsigned short addr);
932
933
934
935
936
937
938
939
940#define module_i2c_driver(__i2c_driver) \
941 module_driver(__i2c_driver, i2c_add_driver, \
942 i2c_del_driver)
943
944
945
946
947
948
949
950
951
952#define builtin_i2c_driver(__i2c_driver) \
953 builtin_driver(__i2c_driver, i2c_add_driver)
954
955#endif
956
957#if IS_ENABLED(CONFIG_OF)
958
959struct i2c_client *of_find_i2c_device_by_node(struct device_node *node);
960
961
962struct i2c_adapter *of_find_i2c_adapter_by_node(struct device_node *node);
963
964
965struct i2c_adapter *of_get_i2c_adapter_by_node(struct device_node *node);
966
967const struct of_device_id
968*i2c_of_match_device(const struct of_device_id *matches,
969 struct i2c_client *client);
970
971int of_i2c_get_board_info(struct device *dev, struct device_node *node,
972 struct i2c_board_info *info);
973
974#else
975
976static inline struct i2c_client *of_find_i2c_device_by_node(struct device_node *node)
977{
978 return NULL;
979}
980
981static inline struct i2c_adapter *of_find_i2c_adapter_by_node(struct device_node *node)
982{
983 return NULL;
984}
985
986static inline struct i2c_adapter *of_get_i2c_adapter_by_node(struct device_node *node)
987{
988 return NULL;
989}
990
991static inline const struct of_device_id
992*i2c_of_match_device(const struct of_device_id *matches,
993 struct i2c_client *client)
994{
995 return NULL;
996}
997
998static inline int of_i2c_get_board_info(struct device *dev,
999 struct device_node *node,
1000 struct i2c_board_info *info)
1001{
1002 return -ENOTSUPP;
1003}
1004
1005#endif
1006
1007struct acpi_resource;
1008struct acpi_resource_i2c_serialbus;
1009
1010#if IS_ENABLED(CONFIG_ACPI)
1011bool i2c_acpi_get_i2c_resource(struct acpi_resource *ares,
1012 struct acpi_resource_i2c_serialbus **i2c);
1013int i2c_acpi_client_count(struct acpi_device *adev);
1014u32 i2c_acpi_find_bus_speed(struct device *dev);
1015struct i2c_client *i2c_acpi_new_device(struct device *dev, int index,
1016 struct i2c_board_info *info);
1017struct i2c_adapter *i2c_acpi_find_adapter_by_handle(acpi_handle handle);
1018#else
1019static inline bool i2c_acpi_get_i2c_resource(struct acpi_resource *ares,
1020 struct acpi_resource_i2c_serialbus **i2c)
1021{
1022 return false;
1023}
1024static inline int i2c_acpi_client_count(struct acpi_device *adev)
1025{
1026 return 0;
1027}
1028static inline u32 i2c_acpi_find_bus_speed(struct device *dev)
1029{
1030 return 0;
1031}
1032static inline struct i2c_client *i2c_acpi_new_device(struct device *dev,
1033 int index, struct i2c_board_info *info)
1034{
1035 return ERR_PTR(-ENODEV);
1036}
1037static inline struct i2c_adapter *i2c_acpi_find_adapter_by_handle(acpi_handle handle)
1038{
1039 return NULL;
1040}
1041#endif
1042
1043#endif
1044