LCOV - code coverage report
Current view: top level - include/linux - i2c.h (source / functions) Hit Total Coverage
Test: combined.info Lines: 0 27 0.0 %
Date: 2022-04-01 14:17:54 Functions: 0 0 -
Branches: 0 16 0.0 %

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: GPL-2.0-or-later */
       2                 :            : /*
       3                 :            :  * i2c.h - definitions for the Linux i2c bus interface
       4                 :            :  * Copyright (C) 1995-2000 Simon G. Vogl
       5                 :            :  * Copyright (C) 2013-2019 Wolfram Sang <wsa@the-dreams.de>
       6                 :            :  *
       7                 :            :  * With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi> and
       8                 :            :  * Frodo Looijaard <frodol@dds.nl>
       9                 :            :  */
      10                 :            : #ifndef _LINUX_I2C_H
      11                 :            : #define _LINUX_I2C_H
      12                 :            : 
      13                 :            : #include <linux/acpi.h>           /* for acpi_handle */
      14                 :            : #include <linux/mod_devicetable.h>
      15                 :            : #include <linux/device.h> /* for struct device */
      16                 :            : #include <linux/sched.h>  /* for completion */
      17                 :            : #include <linux/mutex.h>
      18                 :            : #include <linux/rtmutex.h>
      19                 :            : #include <linux/irqdomain.h>              /* for Host Notify IRQ */
      20                 :            : #include <linux/of.h>             /* for struct device_node */
      21                 :            : #include <linux/swab.h>           /* for swab16 */
      22                 :            : #include <uapi/linux/i2c.h>
      23                 :            : 
      24                 :            : extern struct bus_type i2c_bus_type;
      25                 :            : extern struct device_type i2c_adapter_type;
      26                 :            : extern struct device_type i2c_client_type;
      27                 :            : 
      28                 :            : /* --- General options ------------------------------------------------ */
      29                 :            : 
      30                 :            : struct i2c_msg;
      31                 :            : struct i2c_algorithm;
      32                 :            : struct i2c_adapter;
      33                 :            : struct i2c_client;
      34                 :            : struct i2c_driver;
      35                 :            : struct i2c_device_identity;
      36                 :            : union i2c_smbus_data;
      37                 :            : struct i2c_board_info;
      38                 :            : enum i2c_slave_event;
      39                 :            : typedef int (*i2c_slave_cb_t)(struct i2c_client *client,
      40                 :            :                               enum i2c_slave_event event, u8 *val);
      41                 :            : 
      42                 :            : struct module;
      43                 :            : struct property_entry;
      44                 :            : 
      45                 :            : #if IS_ENABLED(CONFIG_I2C)
      46                 :            : /*
      47                 :            :  * The master routines are the ones normally used to transmit data to devices
      48                 :            :  * on a bus (or read from them). Apart from two basic transfer functions to
      49                 :            :  * transmit one message at a time, a more complex version can be used to
      50                 :            :  * transmit an arbitrary number of messages without interruption.
      51                 :            :  * @count must be be less than 64k since msg.len is u16.
      52                 :            :  */
      53                 :            : int i2c_transfer_buffer_flags(const struct i2c_client *client,
      54                 :            :                               char *buf, int count, u16 flags);
      55                 :            : 
      56                 :            : /**
      57                 :            :  * i2c_master_recv - issue a single I2C message in master receive mode
      58                 :            :  * @client: Handle to slave device
      59                 :            :  * @buf: Where to store data read from slave
      60                 :            :  * @count: How many bytes to read, must be less than 64k since msg.len is u16
      61                 :            :  *
      62                 :            :  * Returns negative errno, or else the number of bytes read.
      63                 :            :  */
      64                 :            : static inline int i2c_master_recv(const struct i2c_client *client,
      65                 :            :                                   char *buf, int count)
      66                 :            : {
      67                 :            :         return i2c_transfer_buffer_flags(client, buf, count, I2C_M_RD);
      68                 :            : };
      69                 :            : 
      70                 :            : /**
      71                 :            :  * i2c_master_recv_dmasafe - issue a single I2C message in master receive mode
      72                 :            :  *                           using a DMA safe buffer
      73                 :            :  * @client: Handle to slave device
      74                 :            :  * @buf: Where to store data read from slave, must be safe to use with DMA
      75                 :            :  * @count: How many bytes to read, must be less than 64k since msg.len is u16
      76                 :            :  *
      77                 :            :  * Returns negative errno, or else the number of bytes read.
      78                 :            :  */
      79                 :            : static inline int i2c_master_recv_dmasafe(const struct i2c_client *client,
      80                 :            :                                           char *buf, int count)
      81                 :            : {
      82                 :            :         return i2c_transfer_buffer_flags(client, buf, count,
      83                 :            :                                          I2C_M_RD | I2C_M_DMA_SAFE);
      84                 :            : };
      85                 :            : 
      86                 :            : /**
      87                 :            :  * i2c_master_send - issue a single I2C message in master transmit mode
      88                 :            :  * @client: Handle to slave device
      89                 :            :  * @buf: Data that will be written to the slave
      90                 :            :  * @count: How many bytes to write, must be less than 64k since msg.len is u16
      91                 :            :  *
      92                 :            :  * Returns negative errno, or else the number of bytes written.
      93                 :            :  */
      94                 :            : static inline int i2c_master_send(const struct i2c_client *client,
      95                 :            :                                   const char *buf, int count)
      96                 :            : {
      97                 :            :         return i2c_transfer_buffer_flags(client, (char *)buf, count, 0);
      98                 :            : };
      99                 :            : 
     100                 :            : /**
     101                 :            :  * i2c_master_send_dmasafe - issue a single I2C message in master transmit mode
     102                 :            :  *                           using a DMA safe buffer
     103                 :            :  * @client: Handle to slave device
     104                 :            :  * @buf: Data that will be written to the slave, must be safe to use with DMA
     105                 :            :  * @count: How many bytes to write, must be less than 64k since msg.len is u16
     106                 :            :  *
     107                 :            :  * Returns negative errno, or else the number of bytes written.
     108                 :            :  */
     109                 :            : static inline int i2c_master_send_dmasafe(const struct i2c_client *client,
     110                 :            :                                           const char *buf, int count)
     111                 :            : {
     112                 :            :         return i2c_transfer_buffer_flags(client, (char *)buf, count,
     113                 :            :                                          I2C_M_DMA_SAFE);
     114                 :            : };
     115                 :            : 
     116                 :            : /* Transfer num messages.
     117                 :            :  */
     118                 :            : int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num);
     119                 :            : /* Unlocked flavor */
     120                 :            : int __i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num);
     121                 :            : 
     122                 :            : /* This is the very generalized SMBus access routine. You probably do not
     123                 :            :    want to use this, though; one of the functions below may be much easier,
     124                 :            :    and probably just as fast.
     125                 :            :    Note that we use i2c_adapter here, because you do not need a specific
     126                 :            :    smbus adapter to call this function. */
     127                 :            : s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr,
     128                 :            :                    unsigned short flags, char read_write, u8 command,
     129                 :            :                    int protocol, union i2c_smbus_data *data);
     130                 :            : 
     131                 :            : /* Unlocked flavor */
     132                 :            : s32 __i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr,
     133                 :            :                      unsigned short flags, char read_write, u8 command,
     134                 :            :                      int protocol, union i2c_smbus_data *data);
     135                 :            : 
     136                 :            : /* Now follow the 'nice' access routines. These also document the calling
     137                 :            :    conventions of i2c_smbus_xfer. */
     138                 :            : 
     139                 :            : s32 i2c_smbus_read_byte(const struct i2c_client *client);
     140                 :            : s32 i2c_smbus_write_byte(const struct i2c_client *client, u8 value);
     141                 :            : s32 i2c_smbus_read_byte_data(const struct i2c_client *client, u8 command);
     142                 :            : s32 i2c_smbus_write_byte_data(const struct i2c_client *client,
     143                 :            :                               u8 command, u8 value);
     144                 :            : s32 i2c_smbus_read_word_data(const struct i2c_client *client, u8 command);
     145                 :            : s32 i2c_smbus_write_word_data(const struct i2c_client *client,
     146                 :            :                               u8 command, u16 value);
     147                 :            : 
     148                 :            : static inline s32
     149                 :            : i2c_smbus_read_word_swapped(const struct i2c_client *client, u8 command)
     150                 :            : {
     151                 :            :         s32 value = i2c_smbus_read_word_data(client, command);
     152                 :            : 
     153                 :            :         return (value < 0) ? value : swab16(value);
     154                 :            : }
     155                 :            : 
     156                 :            : static inline s32
     157                 :            : i2c_smbus_write_word_swapped(const struct i2c_client *client,
     158                 :            :                              u8 command, u16 value)
     159                 :            : {
     160                 :            :         return i2c_smbus_write_word_data(client, command, swab16(value));
     161                 :            : }
     162                 :            : 
     163                 :            : /* Returns the number of read bytes */
     164                 :            : s32 i2c_smbus_read_block_data(const struct i2c_client *client,
     165                 :            :                               u8 command, u8 *values);
     166                 :            : s32 i2c_smbus_write_block_data(const struct i2c_client *client,
     167                 :            :                                u8 command, u8 length, const u8 *values);
     168                 :            : /* Returns the number of read bytes */
     169                 :            : s32 i2c_smbus_read_i2c_block_data(const struct i2c_client *client,
     170                 :            :                                   u8 command, u8 length, u8 *values);
     171                 :            : s32 i2c_smbus_write_i2c_block_data(const struct i2c_client *client,
     172                 :            :                                    u8 command, u8 length, const u8 *values);
     173                 :            : s32 i2c_smbus_read_i2c_block_data_or_emulated(const struct i2c_client *client,
     174                 :            :                                               u8 command, u8 length,
     175                 :            :                                               u8 *values);
     176                 :            : int i2c_get_device_id(const struct i2c_client *client,
     177                 :            :                       struct i2c_device_identity *id);
     178                 :            : #endif /* I2C */
     179                 :            : 
     180                 :            : /**
     181                 :            :  * struct i2c_device_identity - i2c client device identification
     182                 :            :  * @manufacturer_id: 0 - 4095, database maintained by NXP
     183                 :            :  * @part_id: 0 - 511, according to manufacturer
     184                 :            :  * @die_revision: 0 - 7, according to manufacturer
     185                 :            :  */
     186                 :            : struct i2c_device_identity {
     187                 :            :         u16 manufacturer_id;
     188                 :            : #define I2C_DEVICE_ID_NXP_SEMICONDUCTORS                0
     189                 :            : #define I2C_DEVICE_ID_NXP_SEMICONDUCTORS_1              1
     190                 :            : #define I2C_DEVICE_ID_NXP_SEMICONDUCTORS_2              2
     191                 :            : #define I2C_DEVICE_ID_NXP_SEMICONDUCTORS_3              3
     192                 :            : #define I2C_DEVICE_ID_RAMTRON_INTERNATIONAL             4
     193                 :            : #define I2C_DEVICE_ID_ANALOG_DEVICES                    5
     194                 :            : #define I2C_DEVICE_ID_STMICROELECTRONICS                6
     195                 :            : #define I2C_DEVICE_ID_ON_SEMICONDUCTOR                  7
     196                 :            : #define I2C_DEVICE_ID_SPRINTEK_CORPORATION              8
     197                 :            : #define I2C_DEVICE_ID_ESPROS_PHOTONICS_AG               9
     198                 :            : #define I2C_DEVICE_ID_FUJITSU_SEMICONDUCTOR            10
     199                 :            : #define I2C_DEVICE_ID_FLIR                             11
     200                 :            : #define I2C_DEVICE_ID_O2MICRO                          12
     201                 :            : #define I2C_DEVICE_ID_ATMEL                            13
     202                 :            : #define I2C_DEVICE_ID_NONE                         0xffff
     203                 :            :         u16 part_id;
     204                 :            :         u8 die_revision;
     205                 :            : };
     206                 :            : 
     207                 :            : enum i2c_alert_protocol {
     208                 :            :         I2C_PROTOCOL_SMBUS_ALERT,
     209                 :            :         I2C_PROTOCOL_SMBUS_HOST_NOTIFY,
     210                 :            : };
     211                 :            : 
     212                 :            : /**
     213                 :            :  * struct i2c_driver - represent an I2C device driver
     214                 :            :  * @class: What kind of i2c device we instantiate (for detect)
     215                 :            :  * @probe: Callback for device binding - soon to be deprecated
     216                 :            :  * @probe_new: New callback for device binding
     217                 :            :  * @remove: Callback for device unbinding
     218                 :            :  * @shutdown: Callback for device shutdown
     219                 :            :  * @alert: Alert callback, for example for the SMBus alert protocol
     220                 :            :  * @command: Callback for bus-wide signaling (optional)
     221                 :            :  * @driver: Device driver model driver
     222                 :            :  * @id_table: List of I2C devices supported by this driver
     223                 :            :  * @detect: Callback for device detection
     224                 :            :  * @address_list: The I2C addresses to probe (for detect)
     225                 :            :  * @clients: List of detected clients we created (for i2c-core use only)
     226                 :            :  * @disable_i2c_core_irq_mapping: Tell the i2c-core to not do irq-mapping
     227                 :            :  *
     228                 :            :  * The driver.owner field should be set to the module owner of this driver.
     229                 :            :  * The driver.name field should be set to the name of this driver.
     230                 :            :  *
     231                 :            :  * For automatic device detection, both @detect and @address_list must
     232                 :            :  * be defined. @class should also be set, otherwise only devices forced
     233                 :            :  * with module parameters will be created. The detect function must
     234                 :            :  * fill at least the name field of the i2c_board_info structure it is
     235                 :            :  * handed upon successful detection, and possibly also the flags field.
     236                 :            :  *
     237                 :            :  * If @detect is missing, the driver will still work fine for enumerated
     238                 :            :  * devices. Detected devices simply won't be supported. This is expected
     239                 :            :  * for the many I2C/SMBus devices which can't be detected reliably, and
     240                 :            :  * the ones which can always be enumerated in practice.
     241                 :            :  *
     242                 :            :  * The i2c_client structure which is handed to the @detect callback is
     243                 :            :  * not a real i2c_client. It is initialized just enough so that you can
     244                 :            :  * call i2c_smbus_read_byte_data and friends on it. Don't do anything
     245                 :            :  * else with it. In particular, calling dev_dbg and friends on it is
     246                 :            :  * not allowed.
     247                 :            :  */
     248                 :            : struct i2c_driver {
     249                 :            :         unsigned int class;
     250                 :            : 
     251                 :            :         /* Standard driver model interfaces */
     252                 :            :         int (*probe)(struct i2c_client *client, const struct i2c_device_id *id);
     253                 :            :         int (*remove)(struct i2c_client *client);
     254                 :            : 
     255                 :            :         /* New driver model interface to aid the seamless removal of the
     256                 :            :          * current probe()'s, more commonly unused than used second parameter.
     257                 :            :          */
     258                 :            :         int (*probe_new)(struct i2c_client *client);
     259                 :            : 
     260                 :            :         /* driver model interfaces that don't relate to enumeration  */
     261                 :            :         void (*shutdown)(struct i2c_client *client);
     262                 :            : 
     263                 :            :         /* Alert callback, for example for the SMBus alert protocol.
     264                 :            :          * The format and meaning of the data value depends on the protocol.
     265                 :            :          * For the SMBus alert protocol, there is a single bit of data passed
     266                 :            :          * as the alert response's low bit ("event flag").
     267                 :            :          * For the SMBus Host Notify protocol, the data corresponds to the
     268                 :            :          * 16-bit payload data reported by the slave device acting as master.
     269                 :            :          */
     270                 :            :         void (*alert)(struct i2c_client *client, enum i2c_alert_protocol protocol,
     271                 :            :                       unsigned int data);
     272                 :            : 
     273                 :            :         /* a ioctl like command that can be used to perform specific functions
     274                 :            :          * with the device.
     275                 :            :          */
     276                 :            :         int (*command)(struct i2c_client *client, unsigned int cmd, void *arg);
     277                 :            : 
     278                 :            :         struct device_driver driver;
     279                 :            :         const struct i2c_device_id *id_table;
     280                 :            : 
     281                 :            :         /* Device detection callback for automatic device creation */
     282                 :            :         int (*detect)(struct i2c_client *client, struct i2c_board_info *info);
     283                 :            :         const unsigned short *address_list;
     284                 :            :         struct list_head clients;
     285                 :            : 
     286                 :            :         bool disable_i2c_core_irq_mapping;
     287                 :            : };
     288                 :            : #define to_i2c_driver(d) container_of(d, struct i2c_driver, driver)
     289                 :            : 
     290                 :            : /**
     291                 :            :  * struct i2c_client - represent an I2C slave device
     292                 :            :  * @flags: see I2C_CLIENT_* for possible flags
     293                 :            :  * @addr: Address used on the I2C bus connected to the parent adapter.
     294                 :            :  * @name: Indicates the type of the device, usually a chip name that's
     295                 :            :  *      generic enough to hide second-sourcing and compatible revisions.
     296                 :            :  * @adapter: manages the bus segment hosting this I2C device
     297                 :            :  * @dev: Driver model device node for the slave.
     298                 :            :  * @init_irq: IRQ that was set at initialization
     299                 :            :  * @irq: indicates the IRQ generated by this device (if any)
     300                 :            :  * @detected: member of an i2c_driver.clients list or i2c-core's
     301                 :            :  *      userspace_devices list
     302                 :            :  * @slave_cb: Callback when I2C slave mode of an adapter is used. The adapter
     303                 :            :  *      calls it to pass on slave events to the slave driver.
     304                 :            :  *
     305                 :            :  * An i2c_client identifies a single device (i.e. chip) connected to an
     306                 :            :  * i2c bus. The behaviour exposed to Linux is defined by the driver
     307                 :            :  * managing the device.
     308                 :            :  */
     309                 :            : struct i2c_client {
     310                 :            :         unsigned short flags;           /* div., see below              */
     311                 :            : #define I2C_CLIENT_PEC          0x04    /* Use Packet Error Checking */
     312                 :            : #define I2C_CLIENT_TEN          0x10    /* we have a ten bit chip address */
     313                 :            :                                         /* Must equal I2C_M_TEN below */
     314                 :            : #define I2C_CLIENT_SLAVE        0x20    /* we are the slave */
     315                 :            : #define I2C_CLIENT_HOST_NOTIFY  0x40    /* We want to use I2C host notify */
     316                 :            : #define I2C_CLIENT_WAKE         0x80    /* for board_info; true iff can wake */
     317                 :            : #define I2C_CLIENT_SCCB         0x9000  /* Use Omnivision SCCB protocol */
     318                 :            :                                         /* Must match I2C_M_STOP|IGNORE_NAK */
     319                 :            : 
     320                 :            :         unsigned short addr;            /* chip address - NOTE: 7bit    */
     321                 :            :                                         /* addresses are stored in the  */
     322                 :            :                                         /* _LOWER_ 7 bits               */
     323                 :            :         char name[I2C_NAME_SIZE];
     324                 :            :         struct i2c_adapter *adapter;    /* the adapter we sit on        */
     325                 :            :         struct device dev;              /* the device structure         */
     326                 :            :         int init_irq;                   /* irq set at initialization    */
     327                 :            :         int irq;                        /* irq issued by device         */
     328                 :            :         struct list_head detected;
     329                 :            : #if IS_ENABLED(CONFIG_I2C_SLAVE)
     330                 :            :         i2c_slave_cb_t slave_cb;        /* callback for slave mode      */
     331                 :            : #endif
     332                 :            : };
     333                 :            : #define to_i2c_client(d) container_of(d, struct i2c_client, dev)
     334                 :            : 
     335                 :            : struct i2c_client *i2c_verify_client(struct device *dev);
     336                 :            : struct i2c_adapter *i2c_verify_adapter(struct device *dev);
     337                 :            : const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id,
     338                 :            :                                          const struct i2c_client *client);
     339                 :            : 
     340                 :            : static inline struct i2c_client *kobj_to_i2c_client(struct kobject *kobj)
     341                 :            : {
     342                 :            :         struct device * const dev = container_of(kobj, struct device, kobj);
     343                 :            :         return to_i2c_client(dev);
     344                 :            : }
     345                 :            : 
     346                 :          0 : static inline void *i2c_get_clientdata(const struct i2c_client *dev)
     347                 :            : {
     348                 :          0 :         return dev_get_drvdata(&dev->dev);
     349                 :            : }
     350                 :            : 
     351                 :          0 : static inline void i2c_set_clientdata(struct i2c_client *dev, void *data)
     352                 :            : {
     353                 :          0 :         dev_set_drvdata(&dev->dev, data);
     354                 :            : }
     355                 :            : 
     356                 :            : /* I2C slave support */
     357                 :            : 
     358                 :            : #if IS_ENABLED(CONFIG_I2C_SLAVE)
     359                 :            : enum i2c_slave_event {
     360                 :            :         I2C_SLAVE_READ_REQUESTED,
     361                 :            :         I2C_SLAVE_WRITE_REQUESTED,
     362                 :            :         I2C_SLAVE_READ_PROCESSED,
     363                 :            :         I2C_SLAVE_WRITE_RECEIVED,
     364                 :            :         I2C_SLAVE_STOP,
     365                 :            : };
     366                 :            : 
     367                 :            : int i2c_slave_register(struct i2c_client *client, i2c_slave_cb_t slave_cb);
     368                 :            : int i2c_slave_unregister(struct i2c_client *client);
     369                 :            : bool i2c_detect_slave_mode(struct device *dev);
     370                 :            : 
     371                 :            : static inline int i2c_slave_event(struct i2c_client *client,
     372                 :            :                                   enum i2c_slave_event event, u8 *val)
     373                 :            : {
     374                 :            :         return client->slave_cb(client, event, val);
     375                 :            : }
     376                 :            : #else
     377                 :            : static inline bool i2c_detect_slave_mode(struct device *dev) { return false; }
     378                 :            : #endif
     379                 :            : 
     380                 :            : /**
     381                 :            :  * struct i2c_board_info - template for device creation
     382                 :            :  * @type: chip type, to initialize i2c_client.name
     383                 :            :  * @flags: to initialize i2c_client.flags
     384                 :            :  * @addr: stored in i2c_client.addr
     385                 :            :  * @dev_name: Overrides the default <busnr>-<addr> dev_name if set
     386                 :            :  * @platform_data: stored in i2c_client.dev.platform_data
     387                 :            :  * @of_node: pointer to OpenFirmware device node
     388                 :            :  * @fwnode: device node supplied by the platform firmware
     389                 :            :  * @properties: additional device properties for the device
     390                 :            :  * @resources: resources associated with the device
     391                 :            :  * @num_resources: number of resources in the @resources array
     392                 :            :  * @irq: stored in i2c_client.irq
     393                 :            :  *
     394                 :            :  * I2C doesn't actually support hardware probing, although controllers and
     395                 :            :  * devices may be able to use I2C_SMBUS_QUICK to tell whether or not there's
     396                 :            :  * a device at a given address.  Drivers commonly need more information than
     397                 :            :  * that, such as chip type, configuration, associated IRQ, and so on.
     398                 :            :  *
     399                 :            :  * i2c_board_info is used to build tables of information listing I2C devices
     400                 :            :  * that are present.  This information is used to grow the driver model tree.
     401                 :            :  * For mainboards this is done statically using i2c_register_board_info();
     402                 :            :  * bus numbers identify adapters that aren't yet available.  For add-on boards,
     403                 :            :  * i2c_new_device() does this dynamically with the adapter already known.
     404                 :            :  */
     405                 :            : struct i2c_board_info {
     406                 :            :         char            type[I2C_NAME_SIZE];
     407                 :            :         unsigned short  flags;
     408                 :            :         unsigned short  addr;
     409                 :            :         const char      *dev_name;
     410                 :            :         void            *platform_data;
     411                 :            :         struct device_node *of_node;
     412                 :            :         struct fwnode_handle *fwnode;
     413                 :            :         const struct property_entry *properties;
     414                 :            :         const struct resource *resources;
     415                 :            :         unsigned int    num_resources;
     416                 :            :         int             irq;
     417                 :            : };
     418                 :            : 
     419                 :            : /**
     420                 :            :  * I2C_BOARD_INFO - macro used to list an i2c device and its address
     421                 :            :  * @dev_type: identifies the device type
     422                 :            :  * @dev_addr: the device's address on the bus.
     423                 :            :  *
     424                 :            :  * This macro initializes essential fields of a struct i2c_board_info,
     425                 :            :  * declaring what has been provided on a particular board.  Optional
     426                 :            :  * fields (such as associated irq, or device-specific platform_data)
     427                 :            :  * are provided using conventional syntax.
     428                 :            :  */
     429                 :            : #define I2C_BOARD_INFO(dev_type, dev_addr) \
     430                 :            :         .type = dev_type, .addr = (dev_addr)
     431                 :            : 
     432                 :            : 
     433                 :            : #if IS_ENABLED(CONFIG_I2C)
     434                 :            : /* Add-on boards should register/unregister their devices; e.g. a board
     435                 :            :  * with integrated I2C, a config eeprom, sensors, and a codec that's
     436                 :            :  * used in conjunction with the primary hardware.
     437                 :            :  */
     438                 :            : struct i2c_client *
     439                 :            : i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info);
     440                 :            : 
     441                 :            : struct i2c_client *
     442                 :            : i2c_new_client_device(struct i2c_adapter *adap, struct i2c_board_info const *info);
     443                 :            : 
     444                 :            : /* If you don't know the exact address of an I2C device, use this variant
     445                 :            :  * instead, which can probe for device presence in a list of possible
     446                 :            :  * addresses. The "probe" callback function is optional. If it is provided,
     447                 :            :  * it must return 1 on successful probe, 0 otherwise. If it is not provided,
     448                 :            :  * a default probing method is used.
     449                 :            :  */
     450                 :            : struct i2c_client *
     451                 :            : i2c_new_scanned_device(struct i2c_adapter *adap,
     452                 :            :                        struct i2c_board_info *info,
     453                 :            :                        unsigned short const *addr_list,
     454                 :            :                        int (*probe)(struct i2c_adapter *adap, unsigned short addr));
     455                 :            : 
     456                 :            : struct i2c_client *
     457                 :            : i2c_new_probed_device(struct i2c_adapter *adap,
     458                 :            :                        struct i2c_board_info *info,
     459                 :            :                        unsigned short const *addr_list,
     460                 :            :                        int (*probe)(struct i2c_adapter *adap, unsigned short addr));
     461                 :            : 
     462                 :            : /* Common custom probe functions */
     463                 :            : int i2c_probe_func_quick_read(struct i2c_adapter *adap, unsigned short addr);
     464                 :            : 
     465                 :            : struct i2c_client *
     466                 :            : i2c_new_dummy_device(struct i2c_adapter *adapter, u16 address);
     467                 :            : 
     468                 :            : struct i2c_client *
     469                 :            : devm_i2c_new_dummy_device(struct device *dev, struct i2c_adapter *adap, u16 address);
     470                 :            : 
     471                 :            : struct i2c_client *
     472                 :            : i2c_new_ancillary_device(struct i2c_client *client,
     473                 :            :                          const char *name,
     474                 :            :                          u16 default_addr);
     475                 :            : 
     476                 :            : void i2c_unregister_device(struct i2c_client *client);
     477                 :            : #endif /* I2C */
     478                 :            : 
     479                 :            : /* Mainboard arch_initcall() code should register all its I2C devices.
     480                 :            :  * This is done at arch_initcall time, before declaring any i2c adapters.
     481                 :            :  * Modules for add-on boards must use other calls.
     482                 :            :  */
     483                 :            : #ifdef CONFIG_I2C_BOARDINFO
     484                 :            : int
     485                 :            : i2c_register_board_info(int busnum, struct i2c_board_info const *info,
     486                 :            :                         unsigned n);
     487                 :            : #else
     488                 :            : static inline int
     489                 :            : i2c_register_board_info(int busnum, struct i2c_board_info const *info,
     490                 :            :                         unsigned n)
     491                 :            : {
     492                 :            :         return 0;
     493                 :            : }
     494                 :            : #endif /* I2C_BOARDINFO */
     495                 :            : 
     496                 :            : /**
     497                 :            :  * struct i2c_algorithm - represent I2C transfer method
     498                 :            :  * @master_xfer: Issue a set of i2c transactions to the given I2C adapter
     499                 :            :  *   defined by the msgs array, with num messages available to transfer via
     500                 :            :  *   the adapter specified by adap.
     501                 :            :  * @master_xfer_atomic: same as @master_xfer. Yet, only using atomic context
     502                 :            :  *   so e.g. PMICs can be accessed very late before shutdown. Optional.
     503                 :            :  * @smbus_xfer: Issue smbus transactions to the given I2C adapter. If this
     504                 :            :  *   is not present, then the bus layer will try and convert the SMBus calls
     505                 :            :  *   into I2C transfers instead.
     506                 :            :  * @smbus_xfer_atomic: same as @smbus_xfer. Yet, only using atomic context
     507                 :            :  *   so e.g. PMICs can be accessed very late before shutdown. Optional.
     508                 :            :  * @functionality: Return the flags that this algorithm/adapter pair supports
     509                 :            :  *   from the ``I2C_FUNC_*`` flags.
     510                 :            :  * @reg_slave: Register given client to I2C slave mode of this adapter
     511                 :            :  * @unreg_slave: Unregister given client from I2C slave mode of this adapter
     512                 :            :  *
     513                 :            :  * The following structs are for those who like to implement new bus drivers:
     514                 :            :  * i2c_algorithm is the interface to a class of hardware solutions which can
     515                 :            :  * be addressed using the same bus algorithms - i.e. bit-banging or the PCF8584
     516                 :            :  * to name two of the most common.
     517                 :            :  *
     518                 :            :  * The return codes from the ``master_xfer{_atomic}`` fields should indicate the
     519                 :            :  * type of error code that occurred during the transfer, as documented in the
     520                 :            :  * Kernel Documentation file Documentation/i2c/fault-codes.rst.
     521                 :            :  */
     522                 :            : struct i2c_algorithm {
     523                 :            :         /*
     524                 :            :          * If an adapter algorithm can't do I2C-level access, set master_xfer
     525                 :            :          * to NULL. If an adapter algorithm can do SMBus access, set
     526                 :            :          * smbus_xfer. If set to NULL, the SMBus protocol is simulated
     527                 :            :          * using common I2C messages.
     528                 :            :          *
     529                 :            :          * master_xfer should return the number of messages successfully
     530                 :            :          * processed, or a negative value on error
     531                 :            :          */
     532                 :            :         int (*master_xfer)(struct i2c_adapter *adap, struct i2c_msg *msgs,
     533                 :            :                            int num);
     534                 :            :         int (*master_xfer_atomic)(struct i2c_adapter *adap,
     535                 :            :                                    struct i2c_msg *msgs, int num);
     536                 :            :         int (*smbus_xfer)(struct i2c_adapter *adap, u16 addr,
     537                 :            :                           unsigned short flags, char read_write,
     538                 :            :                           u8 command, int size, union i2c_smbus_data *data);
     539                 :            :         int (*smbus_xfer_atomic)(struct i2c_adapter *adap, u16 addr,
     540                 :            :                                  unsigned short flags, char read_write,
     541                 :            :                                  u8 command, int size, union i2c_smbus_data *data);
     542                 :            : 
     543                 :            :         /* To determine what the adapter supports */
     544                 :            :         u32 (*functionality)(struct i2c_adapter *adap);
     545                 :            : 
     546                 :            : #if IS_ENABLED(CONFIG_I2C_SLAVE)
     547                 :            :         int (*reg_slave)(struct i2c_client *client);
     548                 :            :         int (*unreg_slave)(struct i2c_client *client);
     549                 :            : #endif
     550                 :            : };
     551                 :            : 
     552                 :            : /**
     553                 :            :  * struct i2c_lock_operations - represent I2C locking operations
     554                 :            :  * @lock_bus: Get exclusive access to an I2C bus segment
     555                 :            :  * @trylock_bus: Try to get exclusive access to an I2C bus segment
     556                 :            :  * @unlock_bus: Release exclusive access to an I2C bus segment
     557                 :            :  *
     558                 :            :  * The main operations are wrapped by i2c_lock_bus and i2c_unlock_bus.
     559                 :            :  */
     560                 :            : struct i2c_lock_operations {
     561                 :            :         void (*lock_bus)(struct i2c_adapter *adapter, unsigned int flags);
     562                 :            :         int (*trylock_bus)(struct i2c_adapter *adapter, unsigned int flags);
     563                 :            :         void (*unlock_bus)(struct i2c_adapter *adapter, unsigned int flags);
     564                 :            : };
     565                 :            : 
     566                 :            : /**
     567                 :            :  * struct i2c_timings - I2C timing information
     568                 :            :  * @bus_freq_hz: the bus frequency in Hz
     569                 :            :  * @scl_rise_ns: time SCL signal takes to rise in ns; t(r) in the I2C specification
     570                 :            :  * @scl_fall_ns: time SCL signal takes to fall in ns; t(f) in the I2C specification
     571                 :            :  * @scl_int_delay_ns: time IP core additionally needs to setup SCL in ns
     572                 :            :  * @sda_fall_ns: time SDA signal takes to fall in ns; t(f) in the I2C specification
     573                 :            :  * @sda_hold_ns: time IP core additionally needs to hold SDA in ns
     574                 :            :  * @digital_filter_width_ns: width in ns of spikes on i2c lines that the IP core
     575                 :            :  *      digital filter can filter out
     576                 :            :  * @analog_filter_cutoff_freq_hz: threshold frequency for the low pass IP core
     577                 :            :  *      analog filter
     578                 :            :  */
     579                 :            : struct i2c_timings {
     580                 :            :         u32 bus_freq_hz;
     581                 :            :         u32 scl_rise_ns;
     582                 :            :         u32 scl_fall_ns;
     583                 :            :         u32 scl_int_delay_ns;
     584                 :            :         u32 sda_fall_ns;
     585                 :            :         u32 sda_hold_ns;
     586                 :            :         u32 digital_filter_width_ns;
     587                 :            :         u32 analog_filter_cutoff_freq_hz;
     588                 :            : };
     589                 :            : 
     590                 :            : /**
     591                 :            :  * struct i2c_bus_recovery_info - I2C bus recovery information
     592                 :            :  * @recover_bus: Recover routine. Either pass driver's recover_bus() routine, or
     593                 :            :  *      i2c_generic_scl_recovery().
     594                 :            :  * @get_scl: This gets current value of SCL line. Mandatory for generic SCL
     595                 :            :  *      recovery. Populated internally for generic GPIO recovery.
     596                 :            :  * @set_scl: This sets/clears the SCL line. Mandatory for generic SCL recovery.
     597                 :            :  *      Populated internally for generic GPIO recovery.
     598                 :            :  * @get_sda: This gets current value of SDA line. This or set_sda() is mandatory
     599                 :            :  *      for generic SCL recovery. Populated internally, if sda_gpio is a valid
     600                 :            :  *      GPIO, for generic GPIO recovery.
     601                 :            :  * @set_sda: This sets/clears the SDA line. This or get_sda() is mandatory for
     602                 :            :  *      generic SCL recovery. Populated internally, if sda_gpio is a valid GPIO,
     603                 :            :  *      for generic GPIO recovery.
     604                 :            :  * @get_bus_free: Returns the bus free state as seen from the IP core in case it
     605                 :            :  *      has a more complex internal logic than just reading SDA. Optional.
     606                 :            :  * @prepare_recovery: This will be called before starting recovery. Platform may
     607                 :            :  *      configure padmux here for SDA/SCL line or something else they want.
     608                 :            :  * @unprepare_recovery: This will be called after completing recovery. Platform
     609                 :            :  *      may configure padmux here for SDA/SCL line or something else they want.
     610                 :            :  * @scl_gpiod: gpiod of the SCL line. Only required for GPIO recovery.
     611                 :            :  * @sda_gpiod: gpiod of the SDA line. Only required for GPIO recovery.
     612                 :            :  */
     613                 :            : struct i2c_bus_recovery_info {
     614                 :            :         int (*recover_bus)(struct i2c_adapter *adap);
     615                 :            : 
     616                 :            :         int (*get_scl)(struct i2c_adapter *adap);
     617                 :            :         void (*set_scl)(struct i2c_adapter *adap, int val);
     618                 :            :         int (*get_sda)(struct i2c_adapter *adap);
     619                 :            :         void (*set_sda)(struct i2c_adapter *adap, int val);
     620                 :            :         int (*get_bus_free)(struct i2c_adapter *adap);
     621                 :            : 
     622                 :            :         void (*prepare_recovery)(struct i2c_adapter *adap);
     623                 :            :         void (*unprepare_recovery)(struct i2c_adapter *adap);
     624                 :            : 
     625                 :            :         /* gpio recovery */
     626                 :            :         struct gpio_desc *scl_gpiod;
     627                 :            :         struct gpio_desc *sda_gpiod;
     628                 :            : };
     629                 :            : 
     630                 :            : int i2c_recover_bus(struct i2c_adapter *adap);
     631                 :            : 
     632                 :            : /* Generic recovery routines */
     633                 :            : int i2c_generic_scl_recovery(struct i2c_adapter *adap);
     634                 :            : 
     635                 :            : /**
     636                 :            :  * struct i2c_adapter_quirks - describe flaws of an i2c adapter
     637                 :            :  * @flags: see I2C_AQ_* for possible flags and read below
     638                 :            :  * @max_num_msgs: maximum number of messages per transfer
     639                 :            :  * @max_write_len: maximum length of a write message
     640                 :            :  * @max_read_len: maximum length of a read message
     641                 :            :  * @max_comb_1st_msg_len: maximum length of the first msg in a combined message
     642                 :            :  * @max_comb_2nd_msg_len: maximum length of the second msg in a combined message
     643                 :            :  *
     644                 :            :  * Note about combined messages: Some I2C controllers can only send one message
     645                 :            :  * per transfer, plus something called combined message or write-then-read.
     646                 :            :  * This is (usually) a small write message followed by a read message and
     647                 :            :  * barely enough to access register based devices like EEPROMs. There is a flag
     648                 :            :  * to support this mode. It implies max_num_msg = 2 and does the length checks
     649                 :            :  * with max_comb_*_len because combined message mode usually has its own
     650                 :            :  * limitations. Because of HW implementations, some controllers can actually do
     651                 :            :  * write-then-anything or other variants. To support that, write-then-read has
     652                 :            :  * been broken out into smaller bits like write-first and read-second which can
     653                 :            :  * be combined as needed.
     654                 :            :  */
     655                 :            : 
     656                 :            : struct i2c_adapter_quirks {
     657                 :            :         u64 flags;
     658                 :            :         int max_num_msgs;
     659                 :            :         u16 max_write_len;
     660                 :            :         u16 max_read_len;
     661                 :            :         u16 max_comb_1st_msg_len;
     662                 :            :         u16 max_comb_2nd_msg_len;
     663                 :            : };
     664                 :            : 
     665                 :            : /* enforce max_num_msgs = 2 and use max_comb_*_len for length checks */
     666                 :            : #define I2C_AQ_COMB                     BIT(0)
     667                 :            : /* first combined message must be write */
     668                 :            : #define I2C_AQ_COMB_WRITE_FIRST         BIT(1)
     669                 :            : /* second combined message must be read */
     670                 :            : #define I2C_AQ_COMB_READ_SECOND         BIT(2)
     671                 :            : /* both combined messages must have the same target address */
     672                 :            : #define I2C_AQ_COMB_SAME_ADDR           BIT(3)
     673                 :            : /* convenience macro for typical write-then read case */
     674                 :            : #define I2C_AQ_COMB_WRITE_THEN_READ     (I2C_AQ_COMB | I2C_AQ_COMB_WRITE_FIRST | \
     675                 :            :                                          I2C_AQ_COMB_READ_SECOND | I2C_AQ_COMB_SAME_ADDR)
     676                 :            : /* clock stretching is not supported */
     677                 :            : #define I2C_AQ_NO_CLK_STRETCH           BIT(4)
     678                 :            : /* message cannot have length of 0 */
     679                 :            : #define I2C_AQ_NO_ZERO_LEN_READ         BIT(5)
     680                 :            : #define I2C_AQ_NO_ZERO_LEN_WRITE        BIT(6)
     681                 :            : #define I2C_AQ_NO_ZERO_LEN              (I2C_AQ_NO_ZERO_LEN_READ | I2C_AQ_NO_ZERO_LEN_WRITE)
     682                 :            : 
     683                 :            : /*
     684                 :            :  * i2c_adapter is the structure used to identify a physical i2c bus along
     685                 :            :  * with the access algorithms necessary to access it.
     686                 :            :  */
     687                 :            : struct i2c_adapter {
     688                 :            :         struct module *owner;
     689                 :            :         unsigned int class;               /* classes to allow probing for */
     690                 :            :         const struct i2c_algorithm *algo; /* the algorithm to access the bus */
     691                 :            :         void *algo_data;
     692                 :            : 
     693                 :            :         /* data fields that are valid for all devices   */
     694                 :            :         const struct i2c_lock_operations *lock_ops;
     695                 :            :         struct rt_mutex bus_lock;
     696                 :            :         struct rt_mutex mux_lock;
     697                 :            : 
     698                 :            :         int timeout;                    /* in jiffies */
     699                 :            :         int retries;
     700                 :            :         struct device dev;              /* the adapter device */
     701                 :            :         unsigned long locked_flags;     /* owned by the I2C core */
     702                 :            : #define I2C_ALF_IS_SUSPENDED            0
     703                 :            : #define I2C_ALF_SUSPEND_REPORTED        1
     704                 :            : 
     705                 :            :         int nr;
     706                 :            :         char name[48];
     707                 :            :         struct completion dev_released;
     708                 :            : 
     709                 :            :         struct mutex userspace_clients_lock;
     710                 :            :         struct list_head userspace_clients;
     711                 :            : 
     712                 :            :         struct i2c_bus_recovery_info *bus_recovery_info;
     713                 :            :         const struct i2c_adapter_quirks *quirks;
     714                 :            : 
     715                 :            :         struct irq_domain *host_notify_domain;
     716                 :            : };
     717                 :            : #define to_i2c_adapter(d) container_of(d, struct i2c_adapter, dev)
     718                 :            : 
     719                 :          0 : static inline void *i2c_get_adapdata(const struct i2c_adapter *adap)
     720                 :            : {
     721         [ #  # ]:          0 :         return dev_get_drvdata(&adap->dev);
     722                 :            : }
     723                 :            : 
     724                 :          0 : static inline void i2c_set_adapdata(struct i2c_adapter *adap, void *data)
     725                 :            : {
     726                 :          0 :         dev_set_drvdata(&adap->dev, data);
     727                 :            : }
     728                 :            : 
     729                 :            : static inline struct i2c_adapter *
     730                 :          0 : i2c_parent_is_i2c_adapter(const struct i2c_adapter *adapter)
     731                 :            : {
     732                 :            : #if IS_ENABLED(CONFIG_I2C_MUX)
     733                 :            :         struct device *parent = adapter->dev.parent;
     734                 :            : 
     735                 :            :         if (parent != NULL && parent->type == &i2c_adapter_type)
     736                 :            :                 return to_i2c_adapter(parent);
     737                 :            :         else
     738                 :            : #endif
     739                 :          0 :                 return NULL;
     740                 :            : }
     741                 :            : 
     742                 :            : int i2c_for_each_dev(void *data, int (*fn)(struct device *dev, void *data));
     743                 :            : 
     744                 :            : /* Adapter locking functions, exported for shared pin cases */
     745                 :            : #define I2C_LOCK_ROOT_ADAPTER BIT(0)
     746                 :            : #define I2C_LOCK_SEGMENT      BIT(1)
     747                 :            : 
     748                 :            : /**
     749                 :            :  * i2c_lock_bus - Get exclusive access to an I2C bus segment
     750                 :            :  * @adapter: Target I2C bus segment
     751                 :            :  * @flags: I2C_LOCK_ROOT_ADAPTER locks the root i2c adapter, I2C_LOCK_SEGMENT
     752                 :            :  *      locks only this branch in the adapter tree
     753                 :            :  */
     754                 :            : static inline void
     755                 :          0 : i2c_lock_bus(struct i2c_adapter *adapter, unsigned int flags)
     756                 :            : {
     757                 :          0 :         adapter->lock_ops->lock_bus(adapter, flags);
     758                 :          0 : }
     759                 :            : 
     760                 :            : /**
     761                 :            :  * i2c_trylock_bus - Try to get exclusive access to an I2C bus segment
     762                 :            :  * @adapter: Target I2C bus segment
     763                 :            :  * @flags: I2C_LOCK_ROOT_ADAPTER tries to locks the root i2c adapter,
     764                 :            :  *      I2C_LOCK_SEGMENT tries to lock only this branch in the adapter tree
     765                 :            :  *
     766                 :            :  * Return: true if the I2C bus segment is locked, false otherwise
     767                 :            :  */
     768                 :            : static inline int
     769                 :          0 : i2c_trylock_bus(struct i2c_adapter *adapter, unsigned int flags)
     770                 :            : {
     771                 :          0 :         return adapter->lock_ops->trylock_bus(adapter, flags);
     772                 :            : }
     773                 :            : 
     774                 :            : /**
     775                 :            :  * i2c_unlock_bus - Release exclusive access to an I2C bus segment
     776                 :            :  * @adapter: Target I2C bus segment
     777                 :            :  * @flags: I2C_LOCK_ROOT_ADAPTER unlocks the root i2c adapter, I2C_LOCK_SEGMENT
     778                 :            :  *      unlocks only this branch in the adapter tree
     779                 :            :  */
     780                 :            : static inline void
     781                 :          0 : i2c_unlock_bus(struct i2c_adapter *adapter, unsigned int flags)
     782                 :            : {
     783                 :          0 :         adapter->lock_ops->unlock_bus(adapter, flags);
     784                 :            : }
     785                 :            : 
     786                 :            : /**
     787                 :            :  * i2c_mark_adapter_suspended - Report suspended state of the adapter to the core
     788                 :            :  * @adap: Adapter to mark as suspended
     789                 :            :  *
     790                 :            :  * When using this helper to mark an adapter as suspended, the core will reject
     791                 :            :  * further transfers to this adapter. The usage of this helper is optional but
     792                 :            :  * recommended for devices having distinct handlers for system suspend and
     793                 :            :  * runtime suspend. More complex devices are free to implement custom solutions
     794                 :            :  * to reject transfers when suspended.
     795                 :            :  */
     796                 :            : static inline void i2c_mark_adapter_suspended(struct i2c_adapter *adap)
     797                 :            : {
     798                 :            :         i2c_lock_bus(adap, I2C_LOCK_ROOT_ADAPTER);
     799                 :            :         set_bit(I2C_ALF_IS_SUSPENDED, &adap->locked_flags);
     800                 :            :         i2c_unlock_bus(adap, I2C_LOCK_ROOT_ADAPTER);
     801                 :            : }
     802                 :            : 
     803                 :            : /**
     804                 :            :  * i2c_mark_adapter_resumed - Report resumed state of the adapter to the core
     805                 :            :  * @adap: Adapter to mark as resumed
     806                 :            :  *
     807                 :            :  * When using this helper to mark an adapter as resumed, the core will allow
     808                 :            :  * further transfers to this adapter. See also further notes to
     809                 :            :  * @i2c_mark_adapter_suspended().
     810                 :            :  */
     811                 :            : static inline void i2c_mark_adapter_resumed(struct i2c_adapter *adap)
     812                 :            : {
     813                 :            :         i2c_lock_bus(adap, I2C_LOCK_ROOT_ADAPTER);
     814                 :            :         clear_bit(I2C_ALF_IS_SUSPENDED, &adap->locked_flags);
     815                 :            :         i2c_unlock_bus(adap, I2C_LOCK_ROOT_ADAPTER);
     816                 :            : }
     817                 :            : 
     818                 :            : /* i2c adapter classes (bitmask) */
     819                 :            : #define I2C_CLASS_HWMON         (1<<0)    /* lm_sensors, ... */
     820                 :            : #define I2C_CLASS_DDC           (1<<3)    /* DDC bus on graphics adapters */
     821                 :            : #define I2C_CLASS_SPD           (1<<7)    /* Memory modules */
     822                 :            : /* Warn users that the adapter doesn't support classes anymore */
     823                 :            : #define I2C_CLASS_DEPRECATED    (1<<8)
     824                 :            : 
     825                 :            : /* Internal numbers to terminate lists */
     826                 :            : #define I2C_CLIENT_END          0xfffeU
     827                 :            : 
     828                 :            : /* Construct an I2C_CLIENT_END-terminated array of i2c addresses */
     829                 :            : #define I2C_ADDRS(addr, addrs...) \
     830                 :            :         ((const unsigned short []){ addr, ## addrs, I2C_CLIENT_END })
     831                 :            : 
     832                 :            : 
     833                 :            : /* ----- functions exported by i2c.o */
     834                 :            : 
     835                 :            : /* administration...
     836                 :            :  */
     837                 :            : #if IS_ENABLED(CONFIG_I2C)
     838                 :            : int i2c_add_adapter(struct i2c_adapter *adap);
     839                 :            : void i2c_del_adapter(struct i2c_adapter *adap);
     840                 :            : int i2c_add_numbered_adapter(struct i2c_adapter *adap);
     841                 :            : 
     842                 :            : int i2c_register_driver(struct module *owner, struct i2c_driver *driver);
     843                 :            : void i2c_del_driver(struct i2c_driver *driver);
     844                 :            : 
     845                 :            : /* use a define to avoid include chaining to get THIS_MODULE */
     846                 :            : #define i2c_add_driver(driver) \
     847                 :            :         i2c_register_driver(THIS_MODULE, driver)
     848                 :            : 
     849                 :            : static inline bool i2c_client_has_driver(struct i2c_client *client)
     850                 :            : {
     851                 :            :         return !IS_ERR_OR_NULL(client) && client->dev.driver;
     852                 :            : }
     853                 :            : 
     854                 :            : /* call the i2c_client->command() of all attached clients with
     855                 :            :  * the given arguments */
     856                 :            : void i2c_clients_command(struct i2c_adapter *adap,
     857                 :            :                          unsigned int cmd, void *arg);
     858                 :            : 
     859                 :            : struct i2c_adapter *i2c_get_adapter(int nr);
     860                 :            : void i2c_put_adapter(struct i2c_adapter *adap);
     861                 :            : unsigned int i2c_adapter_depth(struct i2c_adapter *adapter);
     862                 :            : 
     863                 :            : void i2c_parse_fw_timings(struct device *dev, struct i2c_timings *t, bool use_defaults);
     864                 :            : 
     865                 :            : /* Return the functionality mask */
     866                 :          0 : static inline u32 i2c_get_functionality(struct i2c_adapter *adap)
     867                 :            : {
     868                 :          0 :         return adap->algo->functionality(adap);
     869                 :            : }
     870                 :            : 
     871                 :            : /* Return 1 if adapter supports everything we need, 0 if not. */
     872                 :          0 : static inline int i2c_check_functionality(struct i2c_adapter *adap, u32 func)
     873                 :            : {
     874   [ #  #  #  #  :          0 :         return (func & i2c_get_functionality(adap)) == func;
          #  #  #  #  #  
                      # ]
     875                 :            : }
     876                 :            : 
     877                 :            : /**
     878                 :            :  * i2c_check_quirks() - Function for checking the quirk flags in an i2c adapter
     879                 :            :  * @adap: i2c adapter
     880                 :            :  * @quirks: quirk flags
     881                 :            :  *
     882                 :            :  * Return: true if the adapter has all the specified quirk flags, false if not
     883                 :            :  */
     884                 :            : static inline bool i2c_check_quirks(struct i2c_adapter *adap, u64 quirks)
     885                 :            : {
     886                 :            :         if (!adap->quirks)
     887                 :            :                 return false;
     888                 :            :         return (adap->quirks->flags & quirks) == quirks;
     889                 :            : }
     890                 :            : 
     891                 :            : /* Return the adapter number for a specific adapter */
     892                 :          0 : static inline int i2c_adapter_id(struct i2c_adapter *adap)
     893                 :            : {
     894         [ #  # ]:          0 :         return adap->nr;
     895                 :            : }
     896                 :            : 
     897                 :          0 : static inline u8 i2c_8bit_addr_from_msg(const struct i2c_msg *msg)
     898                 :            : {
     899         [ #  # ]:          0 :         return (msg->addr << 1) | (msg->flags & I2C_M_RD ? 1 : 0);
     900                 :            : }
     901                 :            : 
     902                 :            : u8 *i2c_get_dma_safe_msg_buf(struct i2c_msg *msg, unsigned int threshold);
     903                 :            : void i2c_put_dma_safe_msg_buf(u8 *buf, struct i2c_msg *msg, bool xferred);
     904                 :            : 
     905                 :            : int i2c_handle_smbus_host_notify(struct i2c_adapter *adap, unsigned short addr);
     906                 :            : /**
     907                 :            :  * module_i2c_driver() - Helper macro for registering a modular I2C driver
     908                 :            :  * @__i2c_driver: i2c_driver struct
     909                 :            :  *
     910                 :            :  * Helper macro for I2C drivers which do not do anything special in module
     911                 :            :  * init/exit. This eliminates a lot of boilerplate. Each module may only
     912                 :            :  * use this macro once, and calling it replaces module_init() and module_exit()
     913                 :            :  */
     914                 :            : #define module_i2c_driver(__i2c_driver) \
     915                 :            :         module_driver(__i2c_driver, i2c_add_driver, \
     916                 :            :                         i2c_del_driver)
     917                 :            : 
     918                 :            : /**
     919                 :            :  * builtin_i2c_driver() - Helper macro for registering a builtin I2C driver
     920                 :            :  * @__i2c_driver: i2c_driver struct
     921                 :            :  *
     922                 :            :  * Helper macro for I2C drivers which do not do anything special in their
     923                 :            :  * init. This eliminates a lot of boilerplate. Each driver may only
     924                 :            :  * use this macro once, and calling it replaces device_initcall().
     925                 :            :  */
     926                 :            : #define builtin_i2c_driver(__i2c_driver) \
     927                 :            :         builtin_driver(__i2c_driver, i2c_add_driver)
     928                 :            : 
     929                 :            : #endif /* I2C */
     930                 :            : 
     931                 :            : #if IS_ENABLED(CONFIG_OF)
     932                 :            : /* must call put_device() when done with returned i2c_client device */
     933                 :            : struct i2c_client *of_find_i2c_device_by_node(struct device_node *node);
     934                 :            : 
     935                 :            : /* must call put_device() when done with returned i2c_adapter device */
     936                 :            : struct i2c_adapter *of_find_i2c_adapter_by_node(struct device_node *node);
     937                 :            : 
     938                 :            : /* must call i2c_put_adapter() when done with returned i2c_adapter device */
     939                 :            : struct i2c_adapter *of_get_i2c_adapter_by_node(struct device_node *node);
     940                 :            : 
     941                 :            : const struct of_device_id
     942                 :            : *i2c_of_match_device(const struct of_device_id *matches,
     943                 :            :                      struct i2c_client *client);
     944                 :            : 
     945                 :            : int of_i2c_get_board_info(struct device *dev, struct device_node *node,
     946                 :            :                           struct i2c_board_info *info);
     947                 :            : 
     948                 :            : #else
     949                 :            : 
     950                 :            : static inline struct i2c_client *of_find_i2c_device_by_node(struct device_node *node)
     951                 :            : {
     952                 :            :         return NULL;
     953                 :            : }
     954                 :            : 
     955                 :            : static inline struct i2c_adapter *of_find_i2c_adapter_by_node(struct device_node *node)
     956                 :            : {
     957                 :            :         return NULL;
     958                 :            : }
     959                 :            : 
     960                 :            : static inline struct i2c_adapter *of_get_i2c_adapter_by_node(struct device_node *node)
     961                 :            : {
     962                 :            :         return NULL;
     963                 :            : }
     964                 :            : 
     965                 :            : static inline const struct of_device_id
     966                 :          0 : *i2c_of_match_device(const struct of_device_id *matches,
     967                 :            :                      struct i2c_client *client)
     968                 :            : {
     969                 :          0 :         return NULL;
     970                 :            : }
     971                 :            : 
     972                 :            : static inline int of_i2c_get_board_info(struct device *dev,
     973                 :            :                                         struct device_node *node,
     974                 :            :                                         struct i2c_board_info *info)
     975                 :            : {
     976                 :            :         return -ENOTSUPP;
     977                 :            : }
     978                 :            : 
     979                 :            : #endif /* CONFIG_OF */
     980                 :            : 
     981                 :            : struct acpi_resource;
     982                 :            : struct acpi_resource_i2c_serialbus;
     983                 :            : 
     984                 :            : #if IS_ENABLED(CONFIG_ACPI)
     985                 :            : bool i2c_acpi_get_i2c_resource(struct acpi_resource *ares,
     986                 :            :                                struct acpi_resource_i2c_serialbus **i2c);
     987                 :            : u32 i2c_acpi_find_bus_speed(struct device *dev);
     988                 :            : struct i2c_client *i2c_acpi_new_device(struct device *dev, int index,
     989                 :            :                                        struct i2c_board_info *info);
     990                 :            : struct i2c_adapter *i2c_acpi_find_adapter_by_handle(acpi_handle handle);
     991                 :            : #else
     992                 :            : static inline bool i2c_acpi_get_i2c_resource(struct acpi_resource *ares,
     993                 :            :                                              struct acpi_resource_i2c_serialbus **i2c)
     994                 :            : {
     995                 :            :         return false;
     996                 :            : }
     997                 :            : static inline u32 i2c_acpi_find_bus_speed(struct device *dev)
     998                 :            : {
     999                 :            :         return 0;
    1000                 :            : }
    1001                 :            : static inline struct i2c_client *i2c_acpi_new_device(struct device *dev,
    1002                 :            :                                         int index, struct i2c_board_info *info)
    1003                 :            : {
    1004                 :            :         return NULL;
    1005                 :            : }
    1006                 :            : static inline struct i2c_adapter *i2c_acpi_find_adapter_by_handle(acpi_handle handle)
    1007                 :            : {
    1008                 :            :         return NULL;
    1009                 :            : }
    1010                 :            : #endif /* CONFIG_ACPI */
    1011                 :            : 
    1012                 :            : #endif /* _LINUX_I2C_H */

Generated by: LCOV version 1.14