2019-05-19 07:51:31 -06:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0-or-later */
|
2019-06-03 02:25:35 -06:00
|
|
|
/*
|
|
|
|
* i2c.h - definitions for the Linux i2c bus interface
|
|
|
|
* Copyright (C) 1995-2000 Simon G. Vogl
|
2020-05-02 06:18:35 -06:00
|
|
|
* Copyright (C) 2013-2019 Wolfram Sang <wsa@kernel.org>
|
2019-06-03 02:25:35 -06:00
|
|
|
*
|
|
|
|
* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi> and
|
|
|
|
* Frodo Looijaard <frodol@dds.nl>
|
2019-05-19 07:51:31 -06:00
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifndef _LINUX_I2C_H
|
|
|
|
#define _LINUX_I2C_H
|
|
|
|
|
2019-05-28 17:02:32 -06:00
|
|
|
#include <linux/acpi.h> /* for acpi_handle */
|
2005-10-21 16:23:27 -06:00
|
|
|
#include <linux/mod_devicetable.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/device.h> /* for struct device */
|
2005-10-30 16:03:48 -07:00
|
|
|
#include <linux/sched.h> /* for completion */
|
2006-01-18 15:16:04 -07:00
|
|
|
#include <linux/mutex.h>
|
2017-02-03 02:08:30 -07:00
|
|
|
#include <linux/rtmutex.h>
|
2016-10-13 06:10:40 -06:00
|
|
|
#include <linux/irqdomain.h> /* for Host Notify IRQ */
|
2010-04-13 17:12:28 -06:00
|
|
|
#include <linux/of.h> /* for struct device_node */
|
2011-10-30 06:47:25 -06:00
|
|
|
#include <linux/swab.h> /* for swab16 */
|
2012-10-13 03:46:48 -06:00
|
|
|
#include <uapi/linux/i2c.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-07-14 14:38:35 -06:00
|
|
|
extern struct bus_type i2c_bus_type;
|
2010-08-11 10:21:02 -06:00
|
|
|
extern struct device_type i2c_adapter_type;
|
2017-03-04 12:29:34 -07:00
|
|
|
extern struct device_type i2c_client_type;
|
2008-07-14 14:38:35 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* --- General options ------------------------------------------------ */
|
|
|
|
|
|
|
|
struct i2c_msg;
|
|
|
|
struct i2c_algorithm;
|
|
|
|
struct i2c_adapter;
|
|
|
|
struct i2c_client;
|
|
|
|
struct i2c_driver;
|
2018-01-22 00:32:01 -07:00
|
|
|
struct i2c_device_identity;
|
2005-04-16 16:20:36 -06:00
|
|
|
union i2c_smbus_data;
|
i2c: Add detection capability to new-style drivers
Add a mechanism to let new-style i2c drivers optionally autodetect
devices they would support on selected buses and ask i2c-core to
instantiate them. This is a replacement for legacy i2c drivers, much
cleaner.
Where drivers had to implement both a legacy i2c_driver and a
new-style i2c_driver so far, this mechanism makes it possible to get
rid of the legacy i2c_driver and implement both enumerated and
detected device support with just one (new-style) i2c_driver.
Here is a quick conversion guide for these drivers, step by step:
* Delete the legacy driver definition, registration and removal.
Delete the attach_adapter and detach_client methods of the legacy
driver.
* Change the prototype of the legacy detect function from
static int foo_detect(struct i2c_adapter *adapter, int address, int kind);
to
static int foo_detect(struct i2c_client *client, int kind,
struct i2c_board_info *info);
* Set the new-style driver detect callback to this new function, and
set its address_data to &addr_data (addr_data is generally provided
by I2C_CLIENT_INSMOD.)
* Add the appropriate class to the new-style driver. This is
typically the class the legacy attach_adapter method was checking
for. Class checking is now mandatory (done by i2c-core.) See
<linux/i2c.h> for the list of available classes.
* Remove the i2c_client allocation and freeing from the detect
function. A pre-allocated client is now handed to you by i2c-core,
and is freed automatically.
* Make the detect function fill the type field of the i2c_board_info
structure it was passed as a parameter, and return 0, on success. If
the detection fails, return -ENODEV.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2008-07-14 14:38:36 -06:00
|
|
|
struct i2c_board_info;
|
2014-11-18 09:04:53 -07:00
|
|
|
enum i2c_slave_event;
|
2019-06-03 02:25:32 -06:00
|
|
|
typedef int (*i2c_slave_cb_t)(struct i2c_client *client,
|
|
|
|
enum i2c_slave_event event, u8 *val);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2020-03-24 06:32:11 -06:00
|
|
|
/* I2C Frequency Modes */
|
|
|
|
#define I2C_MAX_STANDARD_MODE_FREQ 100000
|
|
|
|
#define I2C_MAX_FAST_MODE_FREQ 400000
|
|
|
|
#define I2C_MAX_FAST_MODE_PLUS_FREQ 1000000
|
|
|
|
#define I2C_MAX_TURBO_MODE_FREQ 1400000
|
|
|
|
#define I2C_MAX_HIGH_SPEED_MODE_FREQ 3400000
|
|
|
|
#define I2C_MAX_ULTRA_FAST_MODE_FREQ 5000000
|
|
|
|
|
2011-05-26 11:46:22 -06:00
|
|
|
struct module;
|
2017-02-02 18:41:28 -07:00
|
|
|
struct property_entry;
|
2011-05-26 11:46:22 -06:00
|
|
|
|
2017-11-01 14:06:41 -06:00
|
|
|
#if IS_ENABLED(CONFIG_I2C)
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* The master routines are the ones normally used to transmit data to devices
|
2006-12-10 13:21:31 -07:00
|
|
|
* on a bus (or read from them). Apart from two basic transfer functions to
|
|
|
|
* transmit one message at a time, a more complex version can be used to
|
2005-04-16 16:20:36 -06:00
|
|
|
* transmit an arbitrary number of messages without interruption.
|
2020-07-17 17:38:15 -06:00
|
|
|
* @count must be less than 64k since msg.len is u16.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2019-12-04 05:29:36 -07:00
|
|
|
int i2c_transfer_buffer_flags(const struct i2c_client *client,
|
|
|
|
char *buf, int count, u16 flags);
|
2017-11-04 14:20:04 -06:00
|
|
|
|
|
|
|
/**
|
|
|
|
* i2c_master_recv - issue a single I2C message in master receive mode
|
|
|
|
* @client: Handle to slave device
|
|
|
|
* @buf: Where to store data read from slave
|
|
|
|
* @count: How many bytes to read, must be less than 64k since msg.len is u16
|
|
|
|
*
|
|
|
|
* Returns negative errno, or else the number of bytes read.
|
|
|
|
*/
|
|
|
|
static inline int i2c_master_recv(const struct i2c_client *client,
|
|
|
|
char *buf, int count)
|
|
|
|
{
|
|
|
|
return i2c_transfer_buffer_flags(client, buf, count, I2C_M_RD);
|
|
|
|
};
|
|
|
|
|
2017-11-04 14:20:05 -06:00
|
|
|
/**
|
|
|
|
* i2c_master_recv_dmasafe - issue a single I2C message in master receive mode
|
|
|
|
* using a DMA safe buffer
|
|
|
|
* @client: Handle to slave device
|
|
|
|
* @buf: Where to store data read from slave, must be safe to use with DMA
|
|
|
|
* @count: How many bytes to read, must be less than 64k since msg.len is u16
|
|
|
|
*
|
|
|
|
* Returns negative errno, or else the number of bytes read.
|
|
|
|
*/
|
|
|
|
static inline int i2c_master_recv_dmasafe(const struct i2c_client *client,
|
|
|
|
char *buf, int count)
|
|
|
|
{
|
|
|
|
return i2c_transfer_buffer_flags(client, buf, count,
|
|
|
|
I2C_M_RD | I2C_M_DMA_SAFE);
|
|
|
|
};
|
|
|
|
|
2017-11-04 14:20:04 -06:00
|
|
|
/**
|
|
|
|
* i2c_master_send - issue a single I2C message in master transmit mode
|
|
|
|
* @client: Handle to slave device
|
|
|
|
* @buf: Data that will be written to the slave
|
|
|
|
* @count: How many bytes to write, must be less than 64k since msg.len is u16
|
|
|
|
*
|
|
|
|
* Returns negative errno, or else the number of bytes written.
|
|
|
|
*/
|
|
|
|
static inline int i2c_master_send(const struct i2c_client *client,
|
|
|
|
const char *buf, int count)
|
|
|
|
{
|
|
|
|
return i2c_transfer_buffer_flags(client, (char *)buf, count, 0);
|
|
|
|
};
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2017-11-04 14:20:05 -06:00
|
|
|
/**
|
|
|
|
* i2c_master_send_dmasafe - issue a single I2C message in master transmit mode
|
|
|
|
* using a DMA safe buffer
|
|
|
|
* @client: Handle to slave device
|
|
|
|
* @buf: Data that will be written to the slave, must be safe to use with DMA
|
|
|
|
* @count: How many bytes to write, must be less than 64k since msg.len is u16
|
|
|
|
*
|
|
|
|
* Returns negative errno, or else the number of bytes written.
|
|
|
|
*/
|
|
|
|
static inline int i2c_master_send_dmasafe(const struct i2c_client *client,
|
|
|
|
const char *buf, int count)
|
|
|
|
{
|
|
|
|
return i2c_transfer_buffer_flags(client, (char *)buf, count,
|
|
|
|
I2C_M_DMA_SAFE);
|
|
|
|
};
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Transfer num messages.
|
|
|
|
*/
|
2019-12-04 05:29:36 -07:00
|
|
|
int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num);
|
2012-06-29 04:47:19 -06:00
|
|
|
/* Unlocked flavor */
|
2019-12-04 05:29:36 -07:00
|
|
|
int __i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* This is the very generalized SMBus access routine. You probably do not
|
|
|
|
want to use this, though; one of the functions below may be much easier,
|
2006-12-10 13:21:31 -07:00
|
|
|
and probably just as fast.
|
2005-04-16 16:20:36 -06:00
|
|
|
Note that we use i2c_adapter here, because you do not need a specific
|
|
|
|
smbus adapter to call this function. */
|
2018-06-20 02:51:53 -06:00
|
|
|
s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr,
|
|
|
|
unsigned short flags, char read_write, u8 command,
|
|
|
|
int protocol, union i2c_smbus_data *data);
|
|
|
|
|
|
|
|
/* Unlocked flavor */
|
|
|
|
s32 __i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr,
|
|
|
|
unsigned short flags, char read_write, u8 command,
|
|
|
|
int protocol, union i2c_smbus_data *data);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Now follow the 'nice' access routines. These also document the calling
|
2008-07-14 14:38:24 -06:00
|
|
|
conventions of i2c_smbus_xfer. */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2019-12-04 05:29:36 -07:00
|
|
|
s32 i2c_smbus_read_byte(const struct i2c_client *client);
|
|
|
|
s32 i2c_smbus_write_byte(const struct i2c_client *client, u8 value);
|
|
|
|
s32 i2c_smbus_read_byte_data(const struct i2c_client *client, u8 command);
|
|
|
|
s32 i2c_smbus_write_byte_data(const struct i2c_client *client,
|
|
|
|
u8 command, u8 value);
|
|
|
|
s32 i2c_smbus_read_word_data(const struct i2c_client *client, u8 command);
|
|
|
|
s32 i2c_smbus_write_word_data(const struct i2c_client *client,
|
|
|
|
u8 command, u16 value);
|
2011-10-30 06:47:25 -06:00
|
|
|
|
|
|
|
static inline s32
|
|
|
|
i2c_smbus_read_word_swapped(const struct i2c_client *client, u8 command)
|
|
|
|
{
|
|
|
|
s32 value = i2c_smbus_read_word_data(client, command);
|
|
|
|
|
|
|
|
return (value < 0) ? value : swab16(value);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline s32
|
|
|
|
i2c_smbus_write_word_swapped(const struct i2c_client *client,
|
|
|
|
u8 command, u16 value)
|
|
|
|
{
|
|
|
|
return i2c_smbus_write_word_data(client, command, swab16(value));
|
|
|
|
}
|
|
|
|
|
2007-05-01 15:26:34 -06:00
|
|
|
/* Returns the number of read bytes */
|
2019-12-04 05:29:36 -07:00
|
|
|
s32 i2c_smbus_read_block_data(const struct i2c_client *client,
|
|
|
|
u8 command, u8 *values);
|
|
|
|
s32 i2c_smbus_write_block_data(const struct i2c_client *client,
|
|
|
|
u8 command, u8 length, const u8 *values);
|
2005-10-07 16:04:13 -06:00
|
|
|
/* Returns the number of read bytes */
|
2019-12-04 05:29:36 -07:00
|
|
|
s32 i2c_smbus_read_i2c_block_data(const struct i2c_client *client,
|
|
|
|
u8 command, u8 length, u8 *values);
|
|
|
|
s32 i2c_smbus_write_i2c_block_data(const struct i2c_client *client,
|
|
|
|
u8 command, u8 length, const u8 *values);
|
|
|
|
s32 i2c_smbus_read_i2c_block_data_or_emulated(const struct i2c_client *client,
|
|
|
|
u8 command, u8 length,
|
|
|
|
u8 *values);
|
2018-01-22 00:32:01 -07:00
|
|
|
int i2c_get_device_id(const struct i2c_client *client,
|
|
|
|
struct i2c_device_identity *id);
|
2009-06-19 08:58:20 -06:00
|
|
|
#endif /* I2C */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2018-01-22 00:32:01 -07:00
|
|
|
/**
|
|
|
|
* struct i2c_device_identity - i2c client device identification
|
|
|
|
* @manufacturer_id: 0 - 4095, database maintained by NXP
|
|
|
|
* @part_id: 0 - 511, according to manufacturer
|
|
|
|
* @die_revision: 0 - 7, according to manufacturer
|
|
|
|
*/
|
|
|
|
struct i2c_device_identity {
|
|
|
|
u16 manufacturer_id;
|
|
|
|
#define I2C_DEVICE_ID_NXP_SEMICONDUCTORS 0
|
|
|
|
#define I2C_DEVICE_ID_NXP_SEMICONDUCTORS_1 1
|
|
|
|
#define I2C_DEVICE_ID_NXP_SEMICONDUCTORS_2 2
|
|
|
|
#define I2C_DEVICE_ID_NXP_SEMICONDUCTORS_3 3
|
|
|
|
#define I2C_DEVICE_ID_RAMTRON_INTERNATIONAL 4
|
|
|
|
#define I2C_DEVICE_ID_ANALOG_DEVICES 5
|
|
|
|
#define I2C_DEVICE_ID_STMICROELECTRONICS 6
|
|
|
|
#define I2C_DEVICE_ID_ON_SEMICONDUCTOR 7
|
|
|
|
#define I2C_DEVICE_ID_SPRINTEK_CORPORATION 8
|
|
|
|
#define I2C_DEVICE_ID_ESPROS_PHOTONICS_AG 9
|
|
|
|
#define I2C_DEVICE_ID_FUJITSU_SEMICONDUCTOR 10
|
|
|
|
#define I2C_DEVICE_ID_FLIR 11
|
|
|
|
#define I2C_DEVICE_ID_O2MICRO 12
|
|
|
|
#define I2C_DEVICE_ID_ATMEL 13
|
|
|
|
#define I2C_DEVICE_ID_NONE 0xffff
|
|
|
|
u16 part_id;
|
|
|
|
u8 die_revision;
|
|
|
|
};
|
|
|
|
|
2016-06-09 08:53:47 -06:00
|
|
|
enum i2c_alert_protocol {
|
|
|
|
I2C_PROTOCOL_SMBUS_ALERT,
|
2016-06-09 08:53:48 -06:00
|
|
|
I2C_PROTOCOL_SMBUS_HOST_NOTIFY,
|
2016-06-09 08:53:47 -06:00
|
|
|
};
|
|
|
|
|
i2c: Add detection capability to new-style drivers
Add a mechanism to let new-style i2c drivers optionally autodetect
devices they would support on selected buses and ask i2c-core to
instantiate them. This is a replacement for legacy i2c drivers, much
cleaner.
Where drivers had to implement both a legacy i2c_driver and a
new-style i2c_driver so far, this mechanism makes it possible to get
rid of the legacy i2c_driver and implement both enumerated and
detected device support with just one (new-style) i2c_driver.
Here is a quick conversion guide for these drivers, step by step:
* Delete the legacy driver definition, registration and removal.
Delete the attach_adapter and detach_client methods of the legacy
driver.
* Change the prototype of the legacy detect function from
static int foo_detect(struct i2c_adapter *adapter, int address, int kind);
to
static int foo_detect(struct i2c_client *client, int kind,
struct i2c_board_info *info);
* Set the new-style driver detect callback to this new function, and
set its address_data to &addr_data (addr_data is generally provided
by I2C_CLIENT_INSMOD.)
* Add the appropriate class to the new-style driver. This is
typically the class the legacy attach_adapter method was checking
for. Class checking is now mandatory (done by i2c-core.) See
<linux/i2c.h> for the list of available classes.
* Remove the i2c_client allocation and freeing from the detect
function. A pre-allocated client is now handed to you by i2c-core,
and is freed automatically.
* Make the detect function fill the type field of the i2c_board_info
structure it was passed as a parameter, and return 0, on success. If
the detection fails, return -ENODEV.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2008-07-14 14:38:36 -06:00
|
|
|
/**
|
|
|
|
* struct i2c_driver - represent an I2C device driver
|
|
|
|
* @class: What kind of i2c device we instantiate (for detect)
|
2016-11-07 05:47:41 -07:00
|
|
|
* @probe: Callback for device binding - soon to be deprecated
|
|
|
|
* @probe_new: New callback for device binding
|
2009-06-19 08:58:18 -06:00
|
|
|
* @remove: Callback for device unbinding
|
2008-08-28 00:33:23 -06:00
|
|
|
* @shutdown: Callback for device shutdown
|
2010-08-09 17:37:16 -06:00
|
|
|
* @alert: Alert callback, for example for the SMBus alert protocol
|
2008-08-28 00:33:23 -06:00
|
|
|
* @command: Callback for bus-wide signaling (optional)
|
|
|
|
* @driver: Device driver model driver
|
|
|
|
* @id_table: List of I2C devices supported by this driver
|
i2c: Add detection capability to new-style drivers
Add a mechanism to let new-style i2c drivers optionally autodetect
devices they would support on selected buses and ask i2c-core to
instantiate them. This is a replacement for legacy i2c drivers, much
cleaner.
Where drivers had to implement both a legacy i2c_driver and a
new-style i2c_driver so far, this mechanism makes it possible to get
rid of the legacy i2c_driver and implement both enumerated and
detected device support with just one (new-style) i2c_driver.
Here is a quick conversion guide for these drivers, step by step:
* Delete the legacy driver definition, registration and removal.
Delete the attach_adapter and detach_client methods of the legacy
driver.
* Change the prototype of the legacy detect function from
static int foo_detect(struct i2c_adapter *adapter, int address, int kind);
to
static int foo_detect(struct i2c_client *client, int kind,
struct i2c_board_info *info);
* Set the new-style driver detect callback to this new function, and
set its address_data to &addr_data (addr_data is generally provided
by I2C_CLIENT_INSMOD.)
* Add the appropriate class to the new-style driver. This is
typically the class the legacy attach_adapter method was checking
for. Class checking is now mandatory (done by i2c-core.) See
<linux/i2c.h> for the list of available classes.
* Remove the i2c_client allocation and freeing from the detect
function. A pre-allocated client is now handed to you by i2c-core,
and is freed automatically.
* Make the detect function fill the type field of the i2c_board_info
structure it was passed as a parameter, and return 0, on success. If
the detection fails, return -ENODEV.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2008-07-14 14:38:36 -06:00
|
|
|
* @detect: Callback for device detection
|
2009-12-14 13:17:25 -07:00
|
|
|
* @address_list: The I2C addresses to probe (for detect)
|
i2c: Add detection capability to new-style drivers
Add a mechanism to let new-style i2c drivers optionally autodetect
devices they would support on selected buses and ask i2c-core to
instantiate them. This is a replacement for legacy i2c drivers, much
cleaner.
Where drivers had to implement both a legacy i2c_driver and a
new-style i2c_driver so far, this mechanism makes it possible to get
rid of the legacy i2c_driver and implement both enumerated and
detected device support with just one (new-style) i2c_driver.
Here is a quick conversion guide for these drivers, step by step:
* Delete the legacy driver definition, registration and removal.
Delete the attach_adapter and detach_client methods of the legacy
driver.
* Change the prototype of the legacy detect function from
static int foo_detect(struct i2c_adapter *adapter, int address, int kind);
to
static int foo_detect(struct i2c_client *client, int kind,
struct i2c_board_info *info);
* Set the new-style driver detect callback to this new function, and
set its address_data to &addr_data (addr_data is generally provided
by I2C_CLIENT_INSMOD.)
* Add the appropriate class to the new-style driver. This is
typically the class the legacy attach_adapter method was checking
for. Class checking is now mandatory (done by i2c-core.) See
<linux/i2c.h> for the list of available classes.
* Remove the i2c_client allocation and freeing from the detect
function. A pre-allocated client is now handed to you by i2c-core,
and is freed automatically.
* Make the detect function fill the type field of the i2c_board_info
structure it was passed as a parameter, and return 0, on success. If
the detection fails, return -ENODEV.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2008-07-14 14:38:36 -06:00
|
|
|
* @clients: List of detected clients we created (for i2c-core use only)
|
2005-11-26 12:34:05 -07:00
|
|
|
*
|
|
|
|
* The driver.owner field should be set to the module owner of this driver.
|
|
|
|
* The driver.name field should be set to the name of this driver.
|
i2c: Add detection capability to new-style drivers
Add a mechanism to let new-style i2c drivers optionally autodetect
devices they would support on selected buses and ask i2c-core to
instantiate them. This is a replacement for legacy i2c drivers, much
cleaner.
Where drivers had to implement both a legacy i2c_driver and a
new-style i2c_driver so far, this mechanism makes it possible to get
rid of the legacy i2c_driver and implement both enumerated and
detected device support with just one (new-style) i2c_driver.
Here is a quick conversion guide for these drivers, step by step:
* Delete the legacy driver definition, registration and removal.
Delete the attach_adapter and detach_client methods of the legacy
driver.
* Change the prototype of the legacy detect function from
static int foo_detect(struct i2c_adapter *adapter, int address, int kind);
to
static int foo_detect(struct i2c_client *client, int kind,
struct i2c_board_info *info);
* Set the new-style driver detect callback to this new function, and
set its address_data to &addr_data (addr_data is generally provided
by I2C_CLIENT_INSMOD.)
* Add the appropriate class to the new-style driver. This is
typically the class the legacy attach_adapter method was checking
for. Class checking is now mandatory (done by i2c-core.) See
<linux/i2c.h> for the list of available classes.
* Remove the i2c_client allocation and freeing from the detect
function. A pre-allocated client is now handed to you by i2c-core,
and is freed automatically.
* Make the detect function fill the type field of the i2c_board_info
structure it was passed as a parameter, and return 0, on success. If
the detection fails, return -ENODEV.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2008-07-14 14:38:36 -06:00
|
|
|
*
|
2012-10-05 14:23:54 -06:00
|
|
|
* For automatic device detection, both @detect and @address_list must
|
i2c: Add detection capability to new-style drivers
Add a mechanism to let new-style i2c drivers optionally autodetect
devices they would support on selected buses and ask i2c-core to
instantiate them. This is a replacement for legacy i2c drivers, much
cleaner.
Where drivers had to implement both a legacy i2c_driver and a
new-style i2c_driver so far, this mechanism makes it possible to get
rid of the legacy i2c_driver and implement both enumerated and
detected device support with just one (new-style) i2c_driver.
Here is a quick conversion guide for these drivers, step by step:
* Delete the legacy driver definition, registration and removal.
Delete the attach_adapter and detach_client methods of the legacy
driver.
* Change the prototype of the legacy detect function from
static int foo_detect(struct i2c_adapter *adapter, int address, int kind);
to
static int foo_detect(struct i2c_client *client, int kind,
struct i2c_board_info *info);
* Set the new-style driver detect callback to this new function, and
set its address_data to &addr_data (addr_data is generally provided
by I2C_CLIENT_INSMOD.)
* Add the appropriate class to the new-style driver. This is
typically the class the legacy attach_adapter method was checking
for. Class checking is now mandatory (done by i2c-core.) See
<linux/i2c.h> for the list of available classes.
* Remove the i2c_client allocation and freeing from the detect
function. A pre-allocated client is now handed to you by i2c-core,
and is freed automatically.
* Make the detect function fill the type field of the i2c_board_info
structure it was passed as a parameter, and return 0, on success. If
the detection fails, return -ENODEV.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2008-07-14 14:38:36 -06:00
|
|
|
* be defined. @class should also be set, otherwise only devices forced
|
|
|
|
* with module parameters will be created. The detect function must
|
|
|
|
* fill at least the name field of the i2c_board_info structure it is
|
|
|
|
* handed upon successful detection, and possibly also the flags field.
|
|
|
|
*
|
|
|
|
* If @detect is missing, the driver will still work fine for enumerated
|
|
|
|
* devices. Detected devices simply won't be supported. This is expected
|
|
|
|
* for the many I2C/SMBus devices which can't be detected reliably, and
|
|
|
|
* the ones which can always be enumerated in practice.
|
|
|
|
*
|
|
|
|
* The i2c_client structure which is handed to the @detect callback is
|
|
|
|
* not a real i2c_client. It is initialized just enough so that you can
|
|
|
|
* call i2c_smbus_read_byte_data and friends on it. Don't do anything
|
|
|
|
* else with it. In particular, calling dev_dbg and friends on it is
|
|
|
|
* not allowed.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
struct i2c_driver {
|
|
|
|
unsigned int class;
|
|
|
|
|
2009-06-19 08:58:18 -06:00
|
|
|
/* Standard driver model interfaces */
|
2019-06-03 02:25:32 -06:00
|
|
|
int (*probe)(struct i2c_client *client, const struct i2c_device_id *id);
|
|
|
|
int (*remove)(struct i2c_client *client);
|
2007-05-01 15:26:30 -06:00
|
|
|
|
2016-11-07 05:47:41 -07:00
|
|
|
/* New driver model interface to aid the seamless removal of the
|
|
|
|
* current probe()'s, more commonly unused than used second parameter.
|
|
|
|
*/
|
2019-06-03 02:25:32 -06:00
|
|
|
int (*probe_new)(struct i2c_client *client);
|
2016-11-07 05:47:41 -07:00
|
|
|
|
2007-02-13 14:09:00 -07:00
|
|
|
/* driver model interfaces that don't relate to enumeration */
|
2019-06-03 02:25:32 -06:00
|
|
|
void (*shutdown)(struct i2c_client *client);
|
2007-02-13 14:09:00 -07:00
|
|
|
|
2010-03-02 04:23:42 -07:00
|
|
|
/* Alert callback, for example for the SMBus alert protocol.
|
|
|
|
* The format and meaning of the data value depends on the protocol.
|
|
|
|
* For the SMBus alert protocol, there is a single bit of data passed
|
|
|
|
* as the alert response's low bit ("event flag").
|
2016-06-09 08:53:48 -06:00
|
|
|
* For the SMBus Host Notify protocol, the data corresponds to the
|
|
|
|
* 16-bit payload data reported by the slave device acting as master.
|
2010-03-02 04:23:42 -07:00
|
|
|
*/
|
2019-06-03 02:25:32 -06:00
|
|
|
void (*alert)(struct i2c_client *client, enum i2c_alert_protocol protocol,
|
2016-06-09 08:53:47 -06:00
|
|
|
unsigned int data);
|
2010-03-02 04:23:42 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* a ioctl like command that can be used to perform specific functions
|
|
|
|
* with the device.
|
|
|
|
*/
|
2008-10-22 12:21:32 -06:00
|
|
|
int (*command)(struct i2c_client *client, unsigned int cmd, void *arg);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
struct device_driver driver;
|
2008-04-29 15:11:39 -06:00
|
|
|
const struct i2c_device_id *id_table;
|
i2c: Add detection capability to new-style drivers
Add a mechanism to let new-style i2c drivers optionally autodetect
devices they would support on selected buses and ask i2c-core to
instantiate them. This is a replacement for legacy i2c drivers, much
cleaner.
Where drivers had to implement both a legacy i2c_driver and a
new-style i2c_driver so far, this mechanism makes it possible to get
rid of the legacy i2c_driver and implement both enumerated and
detected device support with just one (new-style) i2c_driver.
Here is a quick conversion guide for these drivers, step by step:
* Delete the legacy driver definition, registration and removal.
Delete the attach_adapter and detach_client methods of the legacy
driver.
* Change the prototype of the legacy detect function from
static int foo_detect(struct i2c_adapter *adapter, int address, int kind);
to
static int foo_detect(struct i2c_client *client, int kind,
struct i2c_board_info *info);
* Set the new-style driver detect callback to this new function, and
set its address_data to &addr_data (addr_data is generally provided
by I2C_CLIENT_INSMOD.)
* Add the appropriate class to the new-style driver. This is
typically the class the legacy attach_adapter method was checking
for. Class checking is now mandatory (done by i2c-core.) See
<linux/i2c.h> for the list of available classes.
* Remove the i2c_client allocation and freeing from the detect
function. A pre-allocated client is now handed to you by i2c-core,
and is freed automatically.
* Make the detect function fill the type field of the i2c_board_info
structure it was passed as a parameter, and return 0, on success. If
the detection fails, return -ENODEV.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2008-07-14 14:38:36 -06:00
|
|
|
|
|
|
|
/* Device detection callback for automatic device creation */
|
2019-06-03 02:25:32 -06:00
|
|
|
int (*detect)(struct i2c_client *client, struct i2c_board_info *info);
|
2009-12-14 13:17:25 -07:00
|
|
|
const unsigned short *address_list;
|
i2c: Add detection capability to new-style drivers
Add a mechanism to let new-style i2c drivers optionally autodetect
devices they would support on selected buses and ask i2c-core to
instantiate them. This is a replacement for legacy i2c drivers, much
cleaner.
Where drivers had to implement both a legacy i2c_driver and a
new-style i2c_driver so far, this mechanism makes it possible to get
rid of the legacy i2c_driver and implement both enumerated and
detected device support with just one (new-style) i2c_driver.
Here is a quick conversion guide for these drivers, step by step:
* Delete the legacy driver definition, registration and removal.
Delete the attach_adapter and detach_client methods of the legacy
driver.
* Change the prototype of the legacy detect function from
static int foo_detect(struct i2c_adapter *adapter, int address, int kind);
to
static int foo_detect(struct i2c_client *client, int kind,
struct i2c_board_info *info);
* Set the new-style driver detect callback to this new function, and
set its address_data to &addr_data (addr_data is generally provided
by I2C_CLIENT_INSMOD.)
* Add the appropriate class to the new-style driver. This is
typically the class the legacy attach_adapter method was checking
for. Class checking is now mandatory (done by i2c-core.) See
<linux/i2c.h> for the list of available classes.
* Remove the i2c_client allocation and freeing from the detect
function. A pre-allocated client is now handed to you by i2c-core,
and is freed automatically.
* Make the detect function fill the type field of the i2c_board_info
structure it was passed as a parameter, and return 0, on success. If
the detection fails, return -ENODEV.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2008-07-14 14:38:36 -06:00
|
|
|
struct list_head clients;
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
#define to_i2c_driver(d) container_of(d, struct i2c_driver, driver)
|
|
|
|
|
2007-05-01 15:26:28 -06:00
|
|
|
/**
|
|
|
|
* struct i2c_client - represent an I2C slave device
|
2019-06-03 02:25:34 -06:00
|
|
|
* @flags: see I2C_CLIENT_* for possible flags
|
2007-05-01 15:26:28 -06:00
|
|
|
* @addr: Address used on the I2C bus connected to the parent adapter.
|
|
|
|
* @name: Indicates the type of the device, usually a chip name that's
|
|
|
|
* generic enough to hide second-sourcing and compatible revisions.
|
2007-07-12 06:12:28 -06:00
|
|
|
* @adapter: manages the bus segment hosting this I2C device
|
2007-05-01 15:26:28 -06:00
|
|
|
* @dev: Driver model device node for the slave.
|
2019-12-08 21:35:38 -07:00
|
|
|
* @init_irq: IRQ that was set at initialization
|
2007-07-12 06:12:28 -06:00
|
|
|
* @irq: indicates the IRQ generated by this device (if any)
|
2009-06-19 08:58:20 -06:00
|
|
|
* @detected: member of an i2c_driver.clients list or i2c-core's
|
|
|
|
* userspace_devices list
|
2014-11-18 09:04:53 -07:00
|
|
|
* @slave_cb: Callback when I2C slave mode of an adapter is used. The adapter
|
|
|
|
* calls it to pass on slave events to the slave driver.
|
2007-05-01 15:26:28 -06:00
|
|
|
*
|
|
|
|
* An i2c_client identifies a single device (i.e. chip) connected to an
|
2007-07-12 06:12:28 -06:00
|
|
|
* i2c bus. The behaviour exposed to Linux is defined by the driver
|
|
|
|
* managing the device.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
struct i2c_client {
|
2007-05-01 15:26:28 -06:00
|
|
|
unsigned short flags; /* div., see below */
|
2019-06-03 02:25:34 -06:00
|
|
|
#define I2C_CLIENT_PEC 0x04 /* Use Packet Error Checking */
|
|
|
|
#define I2C_CLIENT_TEN 0x10 /* we have a ten bit chip address */
|
|
|
|
/* Must equal I2C_M_TEN below */
|
|
|
|
#define I2C_CLIENT_SLAVE 0x20 /* we are the slave */
|
|
|
|
#define I2C_CLIENT_HOST_NOTIFY 0x40 /* We want to use I2C host notify */
|
|
|
|
#define I2C_CLIENT_WAKE 0x80 /* for board_info; true iff can wake */
|
|
|
|
#define I2C_CLIENT_SCCB 0x9000 /* Use Omnivision SCCB protocol */
|
|
|
|
/* Must match I2C_M_STOP|IGNORE_NAK */
|
|
|
|
|
2006-12-10 13:21:31 -07:00
|
|
|
unsigned short addr; /* chip address - NOTE: 7bit */
|
2005-04-16 16:20:36 -06:00
|
|
|
/* addresses are stored in the */
|
2005-07-19 16:02:32 -06:00
|
|
|
/* _LOWER_ 7 bits */
|
2007-05-01 15:26:28 -06:00
|
|
|
char name[I2C_NAME_SIZE];
|
2005-04-16 16:20:36 -06:00
|
|
|
struct i2c_adapter *adapter; /* the adapter we sit on */
|
|
|
|
struct device dev; /* the device structure */
|
2019-02-19 12:30:27 -07:00
|
|
|
int init_irq; /* irq set at initialization */
|
2008-07-01 14:38:18 -06:00
|
|
|
int irq; /* irq issued by device */
|
i2c: Add detection capability to new-style drivers
Add a mechanism to let new-style i2c drivers optionally autodetect
devices they would support on selected buses and ask i2c-core to
instantiate them. This is a replacement for legacy i2c drivers, much
cleaner.
Where drivers had to implement both a legacy i2c_driver and a
new-style i2c_driver so far, this mechanism makes it possible to get
rid of the legacy i2c_driver and implement both enumerated and
detected device support with just one (new-style) i2c_driver.
Here is a quick conversion guide for these drivers, step by step:
* Delete the legacy driver definition, registration and removal.
Delete the attach_adapter and detach_client methods of the legacy
driver.
* Change the prototype of the legacy detect function from
static int foo_detect(struct i2c_adapter *adapter, int address, int kind);
to
static int foo_detect(struct i2c_client *client, int kind,
struct i2c_board_info *info);
* Set the new-style driver detect callback to this new function, and
set its address_data to &addr_data (addr_data is generally provided
by I2C_CLIENT_INSMOD.)
* Add the appropriate class to the new-style driver. This is
typically the class the legacy attach_adapter method was checking
for. Class checking is now mandatory (done by i2c-core.) See
<linux/i2c.h> for the list of available classes.
* Remove the i2c_client allocation and freeing from the detect
function. A pre-allocated client is now handed to you by i2c-core,
and is freed automatically.
* Make the detect function fill the type field of the i2c_board_info
structure it was passed as a parameter, and return 0, on success. If
the detection fails, return -ENODEV.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2008-07-14 14:38:36 -06:00
|
|
|
struct list_head detected;
|
2015-01-26 12:59:31 -07:00
|
|
|
#if IS_ENABLED(CONFIG_I2C_SLAVE)
|
2014-11-18 09:04:53 -07:00
|
|
|
i2c_slave_cb_t slave_cb; /* callback for slave mode */
|
2015-01-26 12:59:31 -07:00
|
|
|
#endif
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
#define to_i2c_client(d) container_of(d, struct i2c_client, dev)
|
|
|
|
|
2019-12-04 05:29:36 -07:00
|
|
|
struct i2c_client *i2c_verify_client(struct device *dev);
|
|
|
|
struct i2c_adapter *i2c_verify_adapter(struct device *dev);
|
|
|
|
const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id,
|
|
|
|
const struct i2c_client *client);
|
2008-01-27 10:14:51 -07:00
|
|
|
|
2005-07-27 11:43:03 -06:00
|
|
|
static inline struct i2c_client *kobj_to_i2c_client(struct kobject *kobj)
|
|
|
|
{
|
2007-07-12 06:12:28 -06:00
|
|
|
struct device * const dev = container_of(kobj, struct device, kobj);
|
|
|
|
return to_i2c_client(dev);
|
2005-07-27 11:43:03 -06:00
|
|
|
}
|
|
|
|
|
2020-05-25 06:05:04 -06:00
|
|
|
static inline void *i2c_get_clientdata(const struct i2c_client *client)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2020-05-25 06:05:04 -06:00
|
|
|
return dev_get_drvdata(&client->dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2020-05-25 06:05:04 -06:00
|
|
|
static inline void i2c_set_clientdata(struct i2c_client *client, void *data)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2020-05-25 06:05:04 -06:00
|
|
|
dev_set_drvdata(&client->dev, data);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2014-11-18 09:04:53 -07:00
|
|
|
/* I2C slave support */
|
|
|
|
|
2015-01-26 12:59:31 -07:00
|
|
|
#if IS_ENABLED(CONFIG_I2C_SLAVE)
|
2014-11-18 09:04:53 -07:00
|
|
|
enum i2c_slave_event {
|
2015-03-23 02:26:36 -06:00
|
|
|
I2C_SLAVE_READ_REQUESTED,
|
|
|
|
I2C_SLAVE_WRITE_REQUESTED,
|
|
|
|
I2C_SLAVE_READ_PROCESSED,
|
|
|
|
I2C_SLAVE_WRITE_RECEIVED,
|
2014-11-18 09:04:53 -07:00
|
|
|
I2C_SLAVE_STOP,
|
|
|
|
};
|
|
|
|
|
2019-12-04 05:29:36 -07:00
|
|
|
int i2c_slave_register(struct i2c_client *client, i2c_slave_cb_t slave_cb);
|
|
|
|
int i2c_slave_unregister(struct i2c_client *client);
|
|
|
|
bool i2c_detect_slave_mode(struct device *dev);
|
2014-11-18 09:04:53 -07:00
|
|
|
|
|
|
|
static inline int i2c_slave_event(struct i2c_client *client,
|
|
|
|
enum i2c_slave_event event, u8 *val)
|
|
|
|
{
|
|
|
|
return client->slave_cb(client, event, val);
|
|
|
|
}
|
2017-07-06 11:26:17 -06:00
|
|
|
#else
|
|
|
|
static inline bool i2c_detect_slave_mode(struct device *dev) { return false; }
|
2015-01-26 12:59:31 -07:00
|
|
|
#endif
|
2014-11-18 09:04:53 -07:00
|
|
|
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-01 15:26:31 -06:00
|
|
|
/**
|
|
|
|
* struct i2c_board_info - template for device creation
|
2008-05-18 12:49:41 -06:00
|
|
|
* @type: chip type, to initialize i2c_client.name
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-01 15:26:31 -06:00
|
|
|
* @flags: to initialize i2c_client.flags
|
|
|
|
* @addr: stored in i2c_client.addr
|
2017-10-11 03:41:19 -06:00
|
|
|
* @dev_name: Overrides the default <busnr>-<addr> dev_name if set
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-01 15:26:31 -06:00
|
|
|
* @platform_data: stored in i2c_client.dev.platform_data
|
2010-08-09 17:37:16 -06:00
|
|
|
* @of_node: pointer to OpenFirmware device node
|
2015-03-16 16:49:03 -06:00
|
|
|
* @fwnode: device node supplied by the platform firmware
|
2017-02-02 18:41:28 -07:00
|
|
|
* @properties: additional device properties for the device
|
2017-03-01 12:45:51 -07:00
|
|
|
* @resources: resources associated with the device
|
|
|
|
* @num_resources: number of resources in the @resources array
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-01 15:26:31 -06:00
|
|
|
* @irq: stored in i2c_client.irq
|
2007-07-12 06:12:28 -06:00
|
|
|
*
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-01 15:26:31 -06:00
|
|
|
* I2C doesn't actually support hardware probing, although controllers and
|
|
|
|
* devices may be able to use I2C_SMBUS_QUICK to tell whether or not there's
|
|
|
|
* a device at a given address. Drivers commonly need more information than
|
|
|
|
* that, such as chip type, configuration, associated IRQ, and so on.
|
|
|
|
*
|
|
|
|
* i2c_board_info is used to build tables of information listing I2C devices
|
2009-06-19 08:58:18 -06:00
|
|
|
* that are present. This information is used to grow the driver model tree.
|
|
|
|
* For mainboards this is done statically using i2c_register_board_info();
|
|
|
|
* bus numbers identify adapters that aren't yet available. For add-on boards,
|
2020-06-15 01:58:15 -06:00
|
|
|
* i2c_new_client_device() does this dynamically with the adapter already known.
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-01 15:26:31 -06:00
|
|
|
*/
|
|
|
|
struct i2c_board_info {
|
|
|
|
char type[I2C_NAME_SIZE];
|
|
|
|
unsigned short flags;
|
|
|
|
unsigned short addr;
|
2017-10-11 03:41:19 -06:00
|
|
|
const char *dev_name;
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-01 15:26:31 -06:00
|
|
|
void *platform_data;
|
2010-04-13 17:12:28 -06:00
|
|
|
struct device_node *of_node;
|
2015-03-16 16:49:03 -06:00
|
|
|
struct fwnode_handle *fwnode;
|
2017-02-02 18:41:28 -07:00
|
|
|
const struct property_entry *properties;
|
2017-03-01 12:45:51 -07:00
|
|
|
const struct resource *resources;
|
|
|
|
unsigned int num_resources;
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-01 15:26:31 -06:00
|
|
|
int irq;
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
2008-04-29 15:11:40 -06:00
|
|
|
* I2C_BOARD_INFO - macro used to list an i2c device and its address
|
|
|
|
* @dev_type: identifies the device type
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-01 15:26:31 -06:00
|
|
|
* @dev_addr: the device's address on the bus.
|
|
|
|
*
|
|
|
|
* This macro initializes essential fields of a struct i2c_board_info,
|
|
|
|
* declaring what has been provided on a particular board. Optional
|
2008-04-29 15:11:40 -06:00
|
|
|
* fields (such as associated irq, or device-specific platform_data)
|
|
|
|
* are provided using conventional syntax.
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-01 15:26:31 -06:00
|
|
|
*/
|
2008-10-22 12:21:32 -06:00
|
|
|
#define I2C_BOARD_INFO(dev_type, dev_addr) \
|
2009-04-13 09:02:14 -06:00
|
|
|
.type = dev_type, .addr = (dev_addr)
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-01 15:26:31 -06:00
|
|
|
|
|
|
|
|
2017-11-01 14:06:41 -06:00
|
|
|
#if IS_ENABLED(CONFIG_I2C)
|
2020-06-15 01:58:15 -06:00
|
|
|
/*
|
|
|
|
* Add-on boards should register/unregister their devices; e.g. a board
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-01 15:26:31 -06:00
|
|
|
* with integrated I2C, a config eeprom, sensors, and a codec that's
|
|
|
|
* used in conjunction with the primary hardware.
|
|
|
|
*/
|
2019-12-04 05:29:36 -07:00
|
|
|
struct i2c_client *
|
2019-06-24 11:04:02 -06:00
|
|
|
i2c_new_client_device(struct i2c_adapter *adap, struct i2c_board_info const *info);
|
|
|
|
|
2007-05-01 15:26:31 -06:00
|
|
|
/* If you don't know the exact address of an I2C device, use this variant
|
|
|
|
* instead, which can probe for device presence in a list of possible
|
2010-08-11 10:20:56 -06:00
|
|
|
* addresses. The "probe" callback function is optional. If it is provided,
|
|
|
|
* it must return 1 on successful probe, 0 otherwise. If it is not provided,
|
|
|
|
* a default probing method is used.
|
2007-05-01 15:26:31 -06:00
|
|
|
*/
|
2019-12-04 05:29:36 -07:00
|
|
|
struct i2c_client *
|
2019-11-06 02:50:19 -07:00
|
|
|
i2c_new_scanned_device(struct i2c_adapter *adap,
|
|
|
|
struct i2c_board_info *info,
|
|
|
|
unsigned short const *addr_list,
|
|
|
|
int (*probe)(struct i2c_adapter *adap, unsigned short addr));
|
|
|
|
|
2010-08-11 10:20:57 -06:00
|
|
|
/* Common custom probe functions */
|
2019-12-04 05:29:36 -07:00
|
|
|
int i2c_probe_func_quick_read(struct i2c_adapter *adap, unsigned short addr);
|
2010-08-11 10:20:57 -06:00
|
|
|
|
2019-12-04 05:29:36 -07:00
|
|
|
struct i2c_client *
|
2019-06-24 11:04:02 -06:00
|
|
|
i2c_new_dummy_device(struct i2c_adapter *adapter, u16 address);
|
|
|
|
|
2019-12-04 05:29:36 -07:00
|
|
|
struct i2c_client *
|
2019-05-16 15:13:09 -06:00
|
|
|
devm_i2c_new_dummy_device(struct device *dev, struct i2c_adapter *adap, u16 address);
|
|
|
|
|
2019-12-04 05:29:36 -07:00
|
|
|
struct i2c_client *
|
2019-08-09 09:40:47 -06:00
|
|
|
i2c_new_ancillary_device(struct i2c_client *client,
|
2019-12-04 05:29:36 -07:00
|
|
|
const char *name,
|
|
|
|
u16 default_addr);
|
2016-01-31 08:33:00 -07:00
|
|
|
|
2019-12-04 05:29:36 -07:00
|
|
|
void i2c_unregister_device(struct i2c_client *client);
|
2009-06-19 08:58:20 -06:00
|
|
|
#endif /* I2C */
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-01 15:26:31 -06:00
|
|
|
|
|
|
|
/* Mainboard arch_initcall() code should register all its I2C devices.
|
|
|
|
* This is done at arch_initcall time, before declaring any i2c adapters.
|
|
|
|
* Modules for add-on boards must use other calls.
|
|
|
|
*/
|
2008-02-24 12:03:42 -07:00
|
|
|
#ifdef CONFIG_I2C_BOARDINFO
|
2019-12-04 05:29:36 -07:00
|
|
|
int
|
2008-10-22 12:21:32 -06:00
|
|
|
i2c_register_board_info(int busnum, struct i2c_board_info const *info,
|
|
|
|
unsigned n);
|
2008-02-24 12:03:42 -07:00
|
|
|
#else
|
|
|
|
static inline int
|
2008-10-22 12:21:32 -06:00
|
|
|
i2c_register_board_info(int busnum, struct i2c_board_info const *info,
|
|
|
|
unsigned n)
|
2008-02-24 12:03:42 -07:00
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2009-06-19 08:58:20 -06:00
|
|
|
#endif /* I2C_BOARDINFO */
|
i2c: Add i2c_board_info and i2c_new_device()
This provides partial support for new-style I2C driver binding. It builds
on "struct i2c_board_info" declarations that identify I2C devices on a given
board. This is needed on systems with I2C devices that can't be fully probed
and/or autoconfigured, such as many embedded Linux configurations where the
way a given I2C device is wired may affect how it must be used.
There are two models for declaring such devices:
* LATE -- using a public function i2c_new_device(). This lets modules
declare I2C devices found *AFTER* a given I2C adapter becomes available.
For example, a PCI card could create adapters giving access to utility
chips on that card, and this would be used to associate those chips with
those adapters.
* EARLY -- from arch_initcall() level code, using a non-exported function
i2c_register_board_info(). This copies the declarations *BEFORE* such
an i2c_adapter becomes available, arranging that i2c_new_device() will
be called later when i2c-core registers the relevant i2c_adapter.
For example, arch/.../.../board-*.c files would declare the I2C devices
along with their platform data, and I2C devices would behave much like
PNPACPI devices. (That is, both enumerate from board-specific tables.)
To match the exported i2c_new_device(), the previously-private function
i2c_unregister_device() is now exported.
Pending later patches using these new APIs, this is effectively a NOP.
Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-05-01 15:26:31 -06:00
|
|
|
|
2014-01-26 09:05:36 -07:00
|
|
|
/**
|
|
|
|
* struct i2c_algorithm - represent I2C transfer method
|
|
|
|
* @master_xfer: Issue a set of i2c transactions to the given I2C adapter
|
|
|
|
* defined by the msgs array, with num messages available to transfer via
|
|
|
|
* the adapter specified by adap.
|
2019-04-03 06:40:10 -06:00
|
|
|
* @master_xfer_atomic: same as @master_xfer. Yet, only using atomic context
|
|
|
|
* so e.g. PMICs can be accessed very late before shutdown. Optional.
|
2014-01-26 09:05:36 -07:00
|
|
|
* @smbus_xfer: Issue smbus transactions to the given I2C adapter. If this
|
|
|
|
* is not present, then the bus layer will try and convert the SMBus calls
|
|
|
|
* into I2C transfers instead.
|
2019-04-03 06:40:10 -06:00
|
|
|
* @smbus_xfer_atomic: same as @smbus_xfer. Yet, only using atomic context
|
|
|
|
* so e.g. PMICs can be accessed very late before shutdown. Optional.
|
2014-01-26 09:05:36 -07:00
|
|
|
* @functionality: Return the flags that this algorithm/adapter pair supports
|
2020-03-17 08:54:22 -06:00
|
|
|
* from the ``I2C_FUNC_*`` flags.
|
2014-11-18 09:04:53 -07:00
|
|
|
* @reg_slave: Register given client to I2C slave mode of this adapter
|
|
|
|
* @unreg_slave: Unregister given client from I2C slave mode of this adapter
|
2014-01-26 09:05:36 -07:00
|
|
|
*
|
2005-04-16 16:20:36 -06:00
|
|
|
* The following structs are for those who like to implement new bus drivers:
|
|
|
|
* i2c_algorithm is the interface to a class of hardware solutions which can
|
|
|
|
* be addressed using the same bus algorithms - i.e. bit-banging or the PCF8584
|
|
|
|
* to name two of the most common.
|
2014-01-26 09:05:36 -07:00
|
|
|
*
|
2020-03-17 08:54:22 -06:00
|
|
|
* The return codes from the ``master_xfer{_atomic}`` fields should indicate the
|
2019-04-03 06:40:10 -06:00
|
|
|
* type of error code that occurred during the transfer, as documented in the
|
2019-07-26 06:51:16 -06:00
|
|
|
* Kernel Documentation file Documentation/i2c/fault-codes.rst.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
struct i2c_algorithm {
|
2019-03-02 06:47:29 -07:00
|
|
|
/*
|
|
|
|
* If an adapter algorithm can't do I2C-level access, set master_xfer
|
|
|
|
* to NULL. If an adapter algorithm can do SMBus access, set
|
|
|
|
* smbus_xfer. If set to NULL, the SMBus protocol is simulated
|
|
|
|
* using common I2C messages.
|
|
|
|
*
|
|
|
|
* master_xfer should return the number of messages successfully
|
|
|
|
* processed, or a negative value on error
|
|
|
|
*/
|
2008-10-22 12:21:32 -06:00
|
|
|
int (*master_xfer)(struct i2c_adapter *adap, struct i2c_msg *msgs,
|
|
|
|
int num);
|
2019-04-03 06:40:10 -06:00
|
|
|
int (*master_xfer_atomic)(struct i2c_adapter *adap,
|
|
|
|
struct i2c_msg *msgs, int num);
|
2019-03-02 06:47:29 -07:00
|
|
|
int (*smbus_xfer)(struct i2c_adapter *adap, u16 addr,
|
|
|
|
unsigned short flags, char read_write,
|
|
|
|
u8 command, int size, union i2c_smbus_data *data);
|
2019-04-03 06:40:10 -06:00
|
|
|
int (*smbus_xfer_atomic)(struct i2c_adapter *adap, u16 addr,
|
|
|
|
unsigned short flags, char read_write,
|
|
|
|
u8 command, int size, union i2c_smbus_data *data);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* To determine what the adapter supports */
|
2019-03-02 06:47:29 -07:00
|
|
|
u32 (*functionality)(struct i2c_adapter *adap);
|
2014-11-18 09:04:53 -07:00
|
|
|
|
2015-01-26 12:59:31 -07:00
|
|
|
#if IS_ENABLED(CONFIG_I2C_SLAVE)
|
2014-11-18 09:04:53 -07:00
|
|
|
int (*reg_slave)(struct i2c_client *client);
|
|
|
|
int (*unreg_slave)(struct i2c_client *client);
|
2015-01-26 12:59:31 -07:00
|
|
|
#endif
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2016-08-25 15:07:01 -06:00
|
|
|
/**
|
|
|
|
* struct i2c_lock_operations - represent I2C locking operations
|
|
|
|
* @lock_bus: Get exclusive access to an I2C bus segment
|
|
|
|
* @trylock_bus: Try to get exclusive access to an I2C bus segment
|
|
|
|
* @unlock_bus: Release exclusive access to an I2C bus segment
|
|
|
|
*
|
|
|
|
* The main operations are wrapped by i2c_lock_bus and i2c_unlock_bus.
|
|
|
|
*/
|
|
|
|
struct i2c_lock_operations {
|
2019-06-03 02:25:32 -06:00
|
|
|
void (*lock_bus)(struct i2c_adapter *adapter, unsigned int flags);
|
|
|
|
int (*trylock_bus)(struct i2c_adapter *adapter, unsigned int flags);
|
|
|
|
void (*unlock_bus)(struct i2c_adapter *adapter, unsigned int flags);
|
2016-08-25 15:07:01 -06:00
|
|
|
};
|
|
|
|
|
2015-12-08 02:37:46 -07:00
|
|
|
/**
|
|
|
|
* struct i2c_timings - I2C timing information
|
|
|
|
* @bus_freq_hz: the bus frequency in Hz
|
|
|
|
* @scl_rise_ns: time SCL signal takes to rise in ns; t(r) in the I2C specification
|
|
|
|
* @scl_fall_ns: time SCL signal takes to fall in ns; t(f) in the I2C specification
|
|
|
|
* @scl_int_delay_ns: time IP core additionally needs to setup SCL in ns
|
|
|
|
* @sda_fall_ns: time SDA signal takes to fall in ns; t(f) in the I2C specification
|
2018-07-25 08:39:25 -06:00
|
|
|
* @sda_hold_ns: time IP core additionally needs to hold SDA in ns
|
2019-10-23 06:40:14 -06:00
|
|
|
* @digital_filter_width_ns: width in ns of spikes on i2c lines that the IP core
|
|
|
|
* digital filter can filter out
|
|
|
|
* @analog_filter_cutoff_freq_hz: threshold frequency for the low pass IP core
|
|
|
|
* analog filter
|
2015-12-08 02:37:46 -07:00
|
|
|
*/
|
|
|
|
struct i2c_timings {
|
|
|
|
u32 bus_freq_hz;
|
|
|
|
u32 scl_rise_ns;
|
|
|
|
u32 scl_fall_ns;
|
|
|
|
u32 scl_int_delay_ns;
|
|
|
|
u32 sda_fall_ns;
|
2018-07-25 08:39:25 -06:00
|
|
|
u32 sda_hold_ns;
|
2019-10-23 06:40:14 -06:00
|
|
|
u32 digital_filter_width_ns;
|
|
|
|
u32 analog_filter_cutoff_freq_hz;
|
2015-12-08 02:37:46 -07:00
|
|
|
};
|
|
|
|
|
2012-02-28 05:56:31 -07:00
|
|
|
/**
|
|
|
|
* struct i2c_bus_recovery_info - I2C bus recovery information
|
|
|
|
* @recover_bus: Recover routine. Either pass driver's recover_bus() routine, or
|
2017-11-01 20:40:30 -06:00
|
|
|
* i2c_generic_scl_recovery().
|
2012-02-28 05:56:31 -07:00
|
|
|
* @get_scl: This gets current value of SCL line. Mandatory for generic SCL
|
2018-01-09 06:58:54 -07:00
|
|
|
* recovery. Populated internally for generic GPIO recovery.
|
|
|
|
* @set_scl: This sets/clears the SCL line. Mandatory for generic SCL recovery.
|
|
|
|
* Populated internally for generic GPIO recovery.
|
2018-07-10 15:42:16 -06:00
|
|
|
* @get_sda: This gets current value of SDA line. This or set_sda() is mandatory
|
|
|
|
* for generic SCL recovery. Populated internally, if sda_gpio is a valid
|
|
|
|
* GPIO, for generic GPIO recovery.
|
|
|
|
* @set_sda: This sets/clears the SDA line. This or get_sda() is mandatory for
|
|
|
|
* generic SCL recovery. Populated internally, if sda_gpio is a valid GPIO,
|
|
|
|
* for generic GPIO recovery.
|
2018-07-10 16:24:22 -06:00
|
|
|
* @get_bus_free: Returns the bus free state as seen from the IP core in case it
|
|
|
|
* has a more complex internal logic than just reading SDA. Optional.
|
2012-02-28 05:56:31 -07:00
|
|
|
* @prepare_recovery: This will be called before starting recovery. Platform may
|
|
|
|
* configure padmux here for SDA/SCL line or something else they want.
|
|
|
|
* @unprepare_recovery: This will be called after completing recovery. Platform
|
|
|
|
* may configure padmux here for SDA/SCL line or something else they want.
|
2017-11-01 20:40:24 -06:00
|
|
|
* @scl_gpiod: gpiod of the SCL line. Only required for GPIO recovery.
|
|
|
|
* @sda_gpiod: gpiod of the SDA line. Only required for GPIO recovery.
|
2020-08-04 03:59:24 -06:00
|
|
|
* @pinctrl: pinctrl used by GPIO recovery to change the state of the I2C pins.
|
|
|
|
* Optional.
|
|
|
|
* @pins_default: default pinctrl state of SCL/SDA lines, when they are assigned
|
|
|
|
* to the I2C bus. Optional. Populated internally for GPIO recovery, if
|
|
|
|
* state with the name PINCTRL_STATE_DEFAULT is found and pinctrl is valid.
|
|
|
|
* @pins_gpio: recovery pinctrl state of SCL/SDA lines, when they are used as
|
|
|
|
* GPIOs. Optional. Populated internally for GPIO recovery, if this state
|
|
|
|
* is called "gpio" or "recovery" and pinctrl is valid.
|
2012-02-28 05:56:31 -07:00
|
|
|
*/
|
|
|
|
struct i2c_bus_recovery_info {
|
2018-01-09 06:58:55 -07:00
|
|
|
int (*recover_bus)(struct i2c_adapter *adap);
|
2012-02-28 05:56:31 -07:00
|
|
|
|
2018-01-09 06:58:55 -07:00
|
|
|
int (*get_scl)(struct i2c_adapter *adap);
|
|
|
|
void (*set_scl)(struct i2c_adapter *adap, int val);
|
|
|
|
int (*get_sda)(struct i2c_adapter *adap);
|
2018-01-09 06:58:56 -07:00
|
|
|
void (*set_sda)(struct i2c_adapter *adap, int val);
|
2018-07-10 16:24:22 -06:00
|
|
|
int (*get_bus_free)(struct i2c_adapter *adap);
|
2012-02-28 05:56:31 -07:00
|
|
|
|
2018-01-09 06:58:55 -07:00
|
|
|
void (*prepare_recovery)(struct i2c_adapter *adap);
|
|
|
|
void (*unprepare_recovery)(struct i2c_adapter *adap);
|
2012-02-28 05:56:31 -07:00
|
|
|
|
|
|
|
/* gpio recovery */
|
2017-11-01 20:40:24 -06:00
|
|
|
struct gpio_desc *scl_gpiod;
|
|
|
|
struct gpio_desc *sda_gpiod;
|
2020-08-04 03:59:24 -06:00
|
|
|
struct pinctrl *pinctrl;
|
|
|
|
struct pinctrl_state *pins_default;
|
|
|
|
struct pinctrl_state *pins_gpio;
|
2012-02-28 05:56:31 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
int i2c_recover_bus(struct i2c_adapter *adap);
|
|
|
|
|
|
|
|
/* Generic recovery routines */
|
|
|
|
int i2c_generic_scl_recovery(struct i2c_adapter *adap);
|
|
|
|
|
2015-01-05 07:35:39 -07:00
|
|
|
/**
|
|
|
|
* struct i2c_adapter_quirks - describe flaws of an i2c adapter
|
|
|
|
* @flags: see I2C_AQ_* for possible flags and read below
|
|
|
|
* @max_num_msgs: maximum number of messages per transfer
|
|
|
|
* @max_write_len: maximum length of a write message
|
|
|
|
* @max_read_len: maximum length of a read message
|
|
|
|
* @max_comb_1st_msg_len: maximum length of the first msg in a combined message
|
|
|
|
* @max_comb_2nd_msg_len: maximum length of the second msg in a combined message
|
|
|
|
*
|
|
|
|
* Note about combined messages: Some I2C controllers can only send one message
|
|
|
|
* per transfer, plus something called combined message or write-then-read.
|
|
|
|
* This is (usually) a small write message followed by a read message and
|
|
|
|
* barely enough to access register based devices like EEPROMs. There is a flag
|
|
|
|
* to support this mode. It implies max_num_msg = 2 and does the length checks
|
|
|
|
* with max_comb_*_len because combined message mode usually has its own
|
|
|
|
* limitations. Because of HW implementations, some controllers can actually do
|
|
|
|
* write-then-anything or other variants. To support that, write-then-read has
|
|
|
|
* been broken out into smaller bits like write-first and read-second which can
|
|
|
|
* be combined as needed.
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct i2c_adapter_quirks {
|
|
|
|
u64 flags;
|
|
|
|
int max_num_msgs;
|
|
|
|
u16 max_write_len;
|
|
|
|
u16 max_read_len;
|
|
|
|
u16 max_comb_1st_msg_len;
|
|
|
|
u16 max_comb_2nd_msg_len;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* enforce max_num_msgs = 2 and use max_comb_*_len for length checks */
|
|
|
|
#define I2C_AQ_COMB BIT(0)
|
|
|
|
/* first combined message must be write */
|
|
|
|
#define I2C_AQ_COMB_WRITE_FIRST BIT(1)
|
|
|
|
/* second combined message must be read */
|
|
|
|
#define I2C_AQ_COMB_READ_SECOND BIT(2)
|
|
|
|
/* both combined messages must have the same target address */
|
|
|
|
#define I2C_AQ_COMB_SAME_ADDR BIT(3)
|
|
|
|
/* convenience macro for typical write-then read case */
|
|
|
|
#define I2C_AQ_COMB_WRITE_THEN_READ (I2C_AQ_COMB | I2C_AQ_COMB_WRITE_FIRST | \
|
|
|
|
I2C_AQ_COMB_READ_SECOND | I2C_AQ_COMB_SAME_ADDR)
|
2015-10-29 05:34:23 -06:00
|
|
|
/* clock stretching is not supported */
|
|
|
|
#define I2C_AQ_NO_CLK_STRETCH BIT(4)
|
2018-07-23 14:26:05 -06:00
|
|
|
/* message cannot have length of 0 */
|
|
|
|
#define I2C_AQ_NO_ZERO_LEN_READ BIT(5)
|
|
|
|
#define I2C_AQ_NO_ZERO_LEN_WRITE BIT(6)
|
|
|
|
#define I2C_AQ_NO_ZERO_LEN (I2C_AQ_NO_ZERO_LEN_READ | I2C_AQ_NO_ZERO_LEN_WRITE)
|
2015-01-05 07:35:39 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* i2c_adapter is the structure used to identify a physical i2c bus along
|
|
|
|
* with the access algorithms necessary to access it.
|
|
|
|
*/
|
|
|
|
struct i2c_adapter {
|
|
|
|
struct module *owner;
|
2008-10-22 12:21:30 -06:00
|
|
|
unsigned int class; /* classes to allow probing for */
|
2006-09-03 14:37:11 -06:00
|
|
|
const struct i2c_algorithm *algo; /* the algorithm to access the bus */
|
2005-04-16 16:20:36 -06:00
|
|
|
void *algo_data;
|
|
|
|
|
|
|
|
/* data fields that are valid for all devices */
|
2016-08-25 15:07:01 -06:00
|
|
|
const struct i2c_lock_operations *lock_ops;
|
2009-12-06 09:06:22 -07:00
|
|
|
struct rt_mutex bus_lock;
|
i2c: mux: relax locking of the top i2c adapter during mux-locked muxing
With a i2c topology like the following
GPIO ---| ------ BAT1
| v /
I2C -----+----------+---- MUX
| \
EEPROM ------ BAT2
there is a locking problem with the GPIO controller since it is a client
on the same i2c bus that it muxes. Transfers to the mux clients (e.g. BAT1)
will lock the whole i2c bus prior to attempting to switch the mux to the
correct i2c segment. In the above case, the GPIO device is an I/O expander
with an i2c interface, and since the GPIO subsystem knows nothing (and
rightfully so) about the lockless needs of the i2c mux code, this results
in a deadlock when the GPIO driver issues i2c transfers to modify the
mux.
So, observing that while it is needed to have the i2c bus locked during the
actual MUX update in order to avoid random garbage on the slave side, it
is not strictly a must to have it locked over the whole sequence of a full
select-transfer-deselect mux client operation. The mux itself needs to be
locked, so transfers to clients behind the mux are serialized, and the mux
needs to be stable during all i2c traffic (otherwise individual mux slave
segments might see garbage, or worse).
Introduce this new locking concept as "mux-locked" muxes, and call the
pre-existing mux locking scheme "parent-locked".
Modify the i2c mux locking so that muxes that are "mux-locked" locks only
the muxes on the parent adapter instead of the whole i2c bus when there is
a transfer to the slave side of the mux. This lock serializes transfers to
the slave side of the muxes on the parent adapter.
Add code to i2c-mux-gpio and i2c-mux-pinctrl that checks if all involved
gpio/pinctrl devices have a parent that is an i2c adapter in the same
adapter tree that is muxed, and request a "mux-locked mux" if that is the
case.
Modify the select-transfer-deselect code for "mux-locked" muxes so
that each of the select-transfer-deselect ops locks the mux parent
adapter individually.
Signed-off-by: Peter Rosin <peda@axentia.se>
Signed-off-by: Wolfram Sang <wsa@the-dreams.de>
2016-05-04 14:15:29 -06:00
|
|
|
struct rt_mutex mux_lock;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-02-24 11:19:49 -07:00
|
|
|
int timeout; /* in jiffies */
|
2005-04-16 16:20:36 -06:00
|
|
|
int retries;
|
|
|
|
struct device dev; /* the adapter device */
|
2018-12-19 09:48:17 -07:00
|
|
|
unsigned long locked_flags; /* owned by the I2C core */
|
2019-04-25 08:19:47 -06:00
|
|
|
#define I2C_ALF_IS_SUSPENDED 0
|
|
|
|
#define I2C_ALF_SUSPEND_REPORTED 1
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
int nr;
|
2007-05-01 15:26:28 -06:00
|
|
|
char name[48];
|
2005-04-16 16:20:36 -06:00
|
|
|
struct completion dev_released;
|
2010-05-04 03:09:28 -06:00
|
|
|
|
2010-08-11 10:21:01 -06:00
|
|
|
struct mutex userspace_clients_lock;
|
2010-05-04 03:09:28 -06:00
|
|
|
struct list_head userspace_clients;
|
2012-02-28 05:56:31 -07:00
|
|
|
|
|
|
|
struct i2c_bus_recovery_info *bus_recovery_info;
|
2015-01-05 07:35:39 -07:00
|
|
|
const struct i2c_adapter_quirks *quirks;
|
2016-10-13 06:10:40 -06:00
|
|
|
|
|
|
|
struct irq_domain *host_notify_domain;
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
2007-05-01 15:26:28 -06:00
|
|
|
#define to_i2c_adapter(d) container_of(d, struct i2c_adapter, dev)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2019-06-03 02:25:31 -06:00
|
|
|
static inline void *i2c_get_adapdata(const struct i2c_adapter *adap)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2019-06-03 02:25:31 -06:00
|
|
|
return dev_get_drvdata(&adap->dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2019-06-03 02:25:31 -06:00
|
|
|
static inline void i2c_set_adapdata(struct i2c_adapter *adap, void *data)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2019-06-03 02:25:31 -06:00
|
|
|
dev_set_drvdata(&adap->dev, data);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2010-10-24 10:16:57 -06:00
|
|
|
static inline struct i2c_adapter *
|
|
|
|
i2c_parent_is_i2c_adapter(const struct i2c_adapter *adapter)
|
2010-08-11 10:21:02 -06:00
|
|
|
{
|
2014-01-13 14:29:04 -07:00
|
|
|
#if IS_ENABLED(CONFIG_I2C_MUX)
|
2010-10-24 10:16:57 -06:00
|
|
|
struct device *parent = adapter->dev.parent;
|
|
|
|
|
|
|
|
if (parent != NULL && parent->type == &i2c_adapter_type)
|
|
|
|
return to_i2c_adapter(parent);
|
|
|
|
else
|
2013-06-26 01:56:35 -06:00
|
|
|
#endif
|
2010-10-24 10:16:57 -06:00
|
|
|
return NULL;
|
2010-08-11 10:21:02 -06:00
|
|
|
}
|
|
|
|
|
2019-06-03 02:25:32 -06:00
|
|
|
int i2c_for_each_dev(void *data, int (*fn)(struct device *dev, void *data));
|
2011-03-20 07:50:52 -06:00
|
|
|
|
2010-08-11 10:20:58 -06:00
|
|
|
/* Adapter locking functions, exported for shared pin cases */
|
i2c: allow adapter drivers to override the adapter locking
Add i2c_lock_bus() and i2c_unlock_bus(), which call the new lock_bus and
unlock_bus ops in the adapter. These funcs/ops take an additional flags
argument that indicates for what purpose the adapter is locked.
There are two flags, I2C_LOCK_ROOT_ADAPTER and I2C_LOCK_SEGMENT, but they
are both implemented the same. For now. Locking the root adapter means
that the whole bus is locked, locking the segment means that only the
current bus segment is locked (i.e. i2c traffic on the parent side of
a mux is still allowed even if the child side of the mux is locked).
Also support a trylock_bus op (but no function to call it, as it is not
expected to be needed outside of the i2c core).
Implement i2c_lock_adapter/i2c_unlock_adapter in terms of the new locking
scheme (i.e. lock with the I2C_LOCK_ROOT_ADAPTER flag).
Locking the root adapter and locking the segment is the same thing for
all root adapters (e.g. in the normal case of a simple topology with no
i2c muxes). The two locking variants are also the same for traditional
muxes (aka parent-locked muxes). These muxes traverse the tree, locking
each level as they go until they reach the root. This patch is preparatory
for a later patch in the series introducing mux-locked muxes, which behave
differently depending on the requested locking. Since all current users
are using i2c_lock_adapter, which is a wrapper for I2C_LOCK_ROOT_ADAPTER,
we only need to annotate the calls that will not need to lock the root
adapter for mux-locked muxes. I.e. the instances that needs to use
I2C_LOCK_SEGMENT instead of i2c_lock_adapter/I2C_LOCK_ROOT_ADAPTER. Those
instances are in the i2c_transfer and i2c_smbus_xfer functions, so that
mux-locked muxes can single out normal i2c accesses to its slave side
and adjust the locking for those accesses.
Signed-off-by: Peter Rosin <peda@axentia.se>
Signed-off-by: Wolfram Sang <wsa@the-dreams.de>
2016-05-04 14:15:27 -06:00
|
|
|
#define I2C_LOCK_ROOT_ADAPTER BIT(0)
|
|
|
|
#define I2C_LOCK_SEGMENT BIT(1)
|
|
|
|
|
|
|
|
/**
|
|
|
|
* i2c_lock_bus - Get exclusive access to an I2C bus segment
|
|
|
|
* @adapter: Target I2C bus segment
|
|
|
|
* @flags: I2C_LOCK_ROOT_ADAPTER locks the root i2c adapter, I2C_LOCK_SEGMENT
|
|
|
|
* locks only this branch in the adapter tree
|
|
|
|
*/
|
|
|
|
static inline void
|
|
|
|
i2c_lock_bus(struct i2c_adapter *adapter, unsigned int flags)
|
|
|
|
{
|
2016-08-25 15:07:01 -06:00
|
|
|
adapter->lock_ops->lock_bus(adapter, flags);
|
i2c: allow adapter drivers to override the adapter locking
Add i2c_lock_bus() and i2c_unlock_bus(), which call the new lock_bus and
unlock_bus ops in the adapter. These funcs/ops take an additional flags
argument that indicates for what purpose the adapter is locked.
There are two flags, I2C_LOCK_ROOT_ADAPTER and I2C_LOCK_SEGMENT, but they
are both implemented the same. For now. Locking the root adapter means
that the whole bus is locked, locking the segment means that only the
current bus segment is locked (i.e. i2c traffic on the parent side of
a mux is still allowed even if the child side of the mux is locked).
Also support a trylock_bus op (but no function to call it, as it is not
expected to be needed outside of the i2c core).
Implement i2c_lock_adapter/i2c_unlock_adapter in terms of the new locking
scheme (i.e. lock with the I2C_LOCK_ROOT_ADAPTER flag).
Locking the root adapter and locking the segment is the same thing for
all root adapters (e.g. in the normal case of a simple topology with no
i2c muxes). The two locking variants are also the same for traditional
muxes (aka parent-locked muxes). These muxes traverse the tree, locking
each level as they go until they reach the root. This patch is preparatory
for a later patch in the series introducing mux-locked muxes, which behave
differently depending on the requested locking. Since all current users
are using i2c_lock_adapter, which is a wrapper for I2C_LOCK_ROOT_ADAPTER,
we only need to annotate the calls that will not need to lock the root
adapter for mux-locked muxes. I.e. the instances that needs to use
I2C_LOCK_SEGMENT instead of i2c_lock_adapter/I2C_LOCK_ROOT_ADAPTER. Those
instances are in the i2c_transfer and i2c_smbus_xfer functions, so that
mux-locked muxes can single out normal i2c accesses to its slave side
and adjust the locking for those accesses.
Signed-off-by: Peter Rosin <peda@axentia.se>
Signed-off-by: Wolfram Sang <wsa@the-dreams.de>
2016-05-04 14:15:27 -06:00
|
|
|
}
|
|
|
|
|
2016-06-29 07:04:03 -06:00
|
|
|
/**
|
|
|
|
* i2c_trylock_bus - Try to get exclusive access to an I2C bus segment
|
|
|
|
* @adapter: Target I2C bus segment
|
|
|
|
* @flags: I2C_LOCK_ROOT_ADAPTER tries to locks the root i2c adapter,
|
|
|
|
* I2C_LOCK_SEGMENT tries to lock only this branch in the adapter tree
|
|
|
|
*
|
|
|
|
* Return: true if the I2C bus segment is locked, false otherwise
|
|
|
|
*/
|
|
|
|
static inline int
|
|
|
|
i2c_trylock_bus(struct i2c_adapter *adapter, unsigned int flags)
|
|
|
|
{
|
2016-08-25 15:07:01 -06:00
|
|
|
return adapter->lock_ops->trylock_bus(adapter, flags);
|
2016-06-29 07:04:03 -06:00
|
|
|
}
|
|
|
|
|
i2c: allow adapter drivers to override the adapter locking
Add i2c_lock_bus() and i2c_unlock_bus(), which call the new lock_bus and
unlock_bus ops in the adapter. These funcs/ops take an additional flags
argument that indicates for what purpose the adapter is locked.
There are two flags, I2C_LOCK_ROOT_ADAPTER and I2C_LOCK_SEGMENT, but they
are both implemented the same. For now. Locking the root adapter means
that the whole bus is locked, locking the segment means that only the
current bus segment is locked (i.e. i2c traffic on the parent side of
a mux is still allowed even if the child side of the mux is locked).
Also support a trylock_bus op (but no function to call it, as it is not
expected to be needed outside of the i2c core).
Implement i2c_lock_adapter/i2c_unlock_adapter in terms of the new locking
scheme (i.e. lock with the I2C_LOCK_ROOT_ADAPTER flag).
Locking the root adapter and locking the segment is the same thing for
all root adapters (e.g. in the normal case of a simple topology with no
i2c muxes). The two locking variants are also the same for traditional
muxes (aka parent-locked muxes). These muxes traverse the tree, locking
each level as they go until they reach the root. This patch is preparatory
for a later patch in the series introducing mux-locked muxes, which behave
differently depending on the requested locking. Since all current users
are using i2c_lock_adapter, which is a wrapper for I2C_LOCK_ROOT_ADAPTER,
we only need to annotate the calls that will not need to lock the root
adapter for mux-locked muxes. I.e. the instances that needs to use
I2C_LOCK_SEGMENT instead of i2c_lock_adapter/I2C_LOCK_ROOT_ADAPTER. Those
instances are in the i2c_transfer and i2c_smbus_xfer functions, so that
mux-locked muxes can single out normal i2c accesses to its slave side
and adjust the locking for those accesses.
Signed-off-by: Peter Rosin <peda@axentia.se>
Signed-off-by: Wolfram Sang <wsa@the-dreams.de>
2016-05-04 14:15:27 -06:00
|
|
|
/**
|
|
|
|
* i2c_unlock_bus - Release exclusive access to an I2C bus segment
|
|
|
|
* @adapter: Target I2C bus segment
|
|
|
|
* @flags: I2C_LOCK_ROOT_ADAPTER unlocks the root i2c adapter, I2C_LOCK_SEGMENT
|
|
|
|
* unlocks only this branch in the adapter tree
|
|
|
|
*/
|
|
|
|
static inline void
|
|
|
|
i2c_unlock_bus(struct i2c_adapter *adapter, unsigned int flags)
|
|
|
|
{
|
2016-08-25 15:07:01 -06:00
|
|
|
adapter->lock_ops->unlock_bus(adapter, flags);
|
i2c: allow adapter drivers to override the adapter locking
Add i2c_lock_bus() and i2c_unlock_bus(), which call the new lock_bus and
unlock_bus ops in the adapter. These funcs/ops take an additional flags
argument that indicates for what purpose the adapter is locked.
There are two flags, I2C_LOCK_ROOT_ADAPTER and I2C_LOCK_SEGMENT, but they
are both implemented the same. For now. Locking the root adapter means
that the whole bus is locked, locking the segment means that only the
current bus segment is locked (i.e. i2c traffic on the parent side of
a mux is still allowed even if the child side of the mux is locked).
Also support a trylock_bus op (but no function to call it, as it is not
expected to be needed outside of the i2c core).
Implement i2c_lock_adapter/i2c_unlock_adapter in terms of the new locking
scheme (i.e. lock with the I2C_LOCK_ROOT_ADAPTER flag).
Locking the root adapter and locking the segment is the same thing for
all root adapters (e.g. in the normal case of a simple topology with no
i2c muxes). The two locking variants are also the same for traditional
muxes (aka parent-locked muxes). These muxes traverse the tree, locking
each level as they go until they reach the root. This patch is preparatory
for a later patch in the series introducing mux-locked muxes, which behave
differently depending on the requested locking. Since all current users
are using i2c_lock_adapter, which is a wrapper for I2C_LOCK_ROOT_ADAPTER,
we only need to annotate the calls that will not need to lock the root
adapter for mux-locked muxes. I.e. the instances that needs to use
I2C_LOCK_SEGMENT instead of i2c_lock_adapter/I2C_LOCK_ROOT_ADAPTER. Those
instances are in the i2c_transfer and i2c_smbus_xfer functions, so that
mux-locked muxes can single out normal i2c accesses to its slave side
and adjust the locking for those accesses.
Signed-off-by: Peter Rosin <peda@axentia.se>
Signed-off-by: Wolfram Sang <wsa@the-dreams.de>
2016-05-04 14:15:27 -06:00
|
|
|
}
|
|
|
|
|
2018-12-19 09:48:17 -07:00
|
|
|
/**
|
|
|
|
* i2c_mark_adapter_suspended - Report suspended state of the adapter to the core
|
|
|
|
* @adap: Adapter to mark as suspended
|
|
|
|
*
|
|
|
|
* When using this helper to mark an adapter as suspended, the core will reject
|
|
|
|
* further transfers to this adapter. The usage of this helper is optional but
|
|
|
|
* recommended for devices having distinct handlers for system suspend and
|
|
|
|
* runtime suspend. More complex devices are free to implement custom solutions
|
|
|
|
* to reject transfers when suspended.
|
|
|
|
*/
|
|
|
|
static inline void i2c_mark_adapter_suspended(struct i2c_adapter *adap)
|
|
|
|
{
|
|
|
|
i2c_lock_bus(adap, I2C_LOCK_ROOT_ADAPTER);
|
|
|
|
set_bit(I2C_ALF_IS_SUSPENDED, &adap->locked_flags);
|
|
|
|
i2c_unlock_bus(adap, I2C_LOCK_ROOT_ADAPTER);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* i2c_mark_adapter_resumed - Report resumed state of the adapter to the core
|
|
|
|
* @adap: Adapter to mark as resumed
|
|
|
|
*
|
|
|
|
* When using this helper to mark an adapter as resumed, the core will allow
|
|
|
|
* further transfers to this adapter. See also further notes to
|
|
|
|
* @i2c_mark_adapter_suspended().
|
|
|
|
*/
|
|
|
|
static inline void i2c_mark_adapter_resumed(struct i2c_adapter *adap)
|
|
|
|
{
|
|
|
|
i2c_lock_bus(adap, I2C_LOCK_ROOT_ADAPTER);
|
|
|
|
clear_bit(I2C_ALF_IS_SUSPENDED, &adap->locked_flags);
|
|
|
|
i2c_unlock_bus(adap, I2C_LOCK_ROOT_ADAPTER);
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* i2c adapter classes (bitmask) */
|
|
|
|
#define I2C_CLASS_HWMON (1<<0) /* lm_sensors, ... */
|
2008-07-14 14:38:28 -06:00
|
|
|
#define I2C_CLASS_DDC (1<<3) /* DDC bus on graphics adapters */
|
2011-05-25 12:43:32 -06:00
|
|
|
#define I2C_CLASS_SPD (1<<7) /* Memory modules */
|
2017-07-29 06:11:43 -06:00
|
|
|
/* Warn users that the adapter doesn't support classes anymore */
|
|
|
|
#define I2C_CLASS_DEPRECATED (1<<8)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Internal numbers to terminate lists */
|
|
|
|
#define I2C_CLIENT_END 0xfffeU
|
|
|
|
|
i2c: New macro to initialize i2c address lists on the fly
For video4linux we sometimes need to probe for a single i2c address.
Normally you would do it like this:
static const unsigned short addrs[] = {
addr, I2C_CLIENT_END
};
client = i2c_new_probed_device(adapter, &info, addrs);
This is a bit awkward and I came up with this macro:
#define V4L2_I2C_ADDRS(addr, addrs...) \
((const unsigned short []){ addr, ## addrs, I2C_CLIENT_END })
This can construct a list of one or more i2c addresses on the fly. But
this is something that really belongs in i2c.h, renamed to I2C_ADDRS.
With this macro we can just do:
client = i2c_new_probed_device(adapter, &info, I2C_ADDRS(addr));
Note that this can also be used to initialize an array:
static const unsigned short addrs[] = I2C_ADDRS(0x2a, 0x2c);
Whether you want to is another matter, but it works. This functionality is
also available in the oldest supported gcc (3.2).
Signed-off-by: Hans Verkuil <hverkuil@xs4all.nl>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2009-06-19 08:58:21 -06:00
|
|
|
/* Construct an I2C_CLIENT_END-terminated array of i2c addresses */
|
|
|
|
#define I2C_ADDRS(addr, addrs...) \
|
|
|
|
((const unsigned short []){ addr, ## addrs, I2C_CLIENT_END })
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* ----- functions exported by i2c.o */
|
|
|
|
|
|
|
|
/* administration...
|
|
|
|
*/
|
2017-11-01 14:06:41 -06:00
|
|
|
#if IS_ENABLED(CONFIG_I2C)
|
2019-12-04 05:29:36 -07:00
|
|
|
int i2c_add_adapter(struct i2c_adapter *adap);
|
|
|
|
void i2c_del_adapter(struct i2c_adapter *adap);
|
|
|
|
int i2c_add_numbered_adapter(struct i2c_adapter *adap);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2019-12-04 05:29:36 -07:00
|
|
|
int i2c_register_driver(struct module *owner, struct i2c_driver *driver);
|
|
|
|
void i2c_del_driver(struct i2c_driver *driver);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-05-27 07:02:11 -06:00
|
|
|
/* use a define to avoid include chaining to get THIS_MODULE */
|
|
|
|
#define i2c_add_driver(driver) \
|
|
|
|
i2c_register_driver(THIS_MODULE, driver)
|
2005-12-06 16:33:15 -07:00
|
|
|
|
2019-11-06 14:21:01 -07:00
|
|
|
static inline bool i2c_client_has_driver(struct i2c_client *client)
|
|
|
|
{
|
|
|
|
return !IS_ERR_OR_NULL(client) && client->dev.driver;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* call the i2c_client->command() of all attached clients with
|
|
|
|
* the given arguments */
|
2019-12-04 05:29:36 -07:00
|
|
|
void i2c_clients_command(struct i2c_adapter *adap,
|
|
|
|
unsigned int cmd, void *arg);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2019-12-04 05:29:36 -07:00
|
|
|
struct i2c_adapter *i2c_get_adapter(int nr);
|
|
|
|
void i2c_put_adapter(struct i2c_adapter *adap);
|
|
|
|
unsigned int i2c_adapter_depth(struct i2c_adapter *adapter);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2015-12-08 02:37:46 -07:00
|
|
|
void i2c_parse_fw_timings(struct device *dev, struct i2c_timings *t, bool use_defaults);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Return the functionality mask */
|
|
|
|
static inline u32 i2c_get_functionality(struct i2c_adapter *adap)
|
|
|
|
{
|
|
|
|
return adap->algo->functionality(adap);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Return 1 if adapter supports everything we need, 0 if not. */
|
|
|
|
static inline int i2c_check_functionality(struct i2c_adapter *adap, u32 func)
|
|
|
|
{
|
|
|
|
return (func & i2c_get_functionality(adap)) == func;
|
|
|
|
}
|
|
|
|
|
2015-10-29 05:34:26 -06:00
|
|
|
/**
|
|
|
|
* i2c_check_quirks() - Function for checking the quirk flags in an i2c adapter
|
|
|
|
* @adap: i2c adapter
|
|
|
|
* @quirks: quirk flags
|
|
|
|
*
|
|
|
|
* Return: true if the adapter has all the specified quirk flags, false if not
|
|
|
|
*/
|
|
|
|
static inline bool i2c_check_quirks(struct i2c_adapter *adap, u64 quirks)
|
|
|
|
{
|
|
|
|
if (!adap->quirks)
|
|
|
|
return false;
|
|
|
|
return (adap->quirks->flags & quirks) == quirks;
|
|
|
|
}
|
|
|
|
|
2008-10-22 12:21:32 -06:00
|
|
|
/* Return the adapter number for a specific adapter */
|
2005-07-28 15:09:40 -06:00
|
|
|
static inline int i2c_adapter_id(struct i2c_adapter *adap)
|
|
|
|
{
|
|
|
|
return adap->nr;
|
|
|
|
}
|
2011-11-16 02:13:36 -07:00
|
|
|
|
2016-04-03 12:44:45 -06:00
|
|
|
static inline u8 i2c_8bit_addr_from_msg(const struct i2c_msg *msg)
|
|
|
|
{
|
|
|
|
return (msg->addr << 1) | (msg->flags & I2C_M_RD ? 1 : 0);
|
|
|
|
}
|
|
|
|
|
2017-11-04 14:20:02 -06:00
|
|
|
u8 *i2c_get_dma_safe_msg_buf(struct i2c_msg *msg, unsigned int threshold);
|
2018-08-24 08:52:44 -06:00
|
|
|
void i2c_put_dma_safe_msg_buf(u8 *buf, struct i2c_msg *msg, bool xferred);
|
2017-11-04 14:20:02 -06:00
|
|
|
|
2016-10-13 06:10:40 -06:00
|
|
|
int i2c_handle_smbus_host_notify(struct i2c_adapter *adap, unsigned short addr);
|
2011-11-16 02:13:36 -07:00
|
|
|
/**
|
2015-12-13 13:33:19 -07:00
|
|
|
* module_i2c_driver() - Helper macro for registering a modular I2C driver
|
2011-11-16 02:13:36 -07:00
|
|
|
* @__i2c_driver: i2c_driver struct
|
|
|
|
*
|
|
|
|
* Helper macro for I2C drivers which do not do anything special in module
|
|
|
|
* init/exit. This eliminates a lot of boilerplate. Each module may only
|
|
|
|
* use this macro once, and calling it replaces module_init() and module_exit()
|
|
|
|
*/
|
|
|
|
#define module_i2c_driver(__i2c_driver) \
|
|
|
|
module_driver(__i2c_driver, i2c_add_driver, \
|
|
|
|
i2c_del_driver)
|
|
|
|
|
2015-12-13 13:33:19 -07:00
|
|
|
/**
|
|
|
|
* builtin_i2c_driver() - Helper macro for registering a builtin I2C driver
|
|
|
|
* @__i2c_driver: i2c_driver struct
|
|
|
|
*
|
|
|
|
* Helper macro for I2C drivers which do not do anything special in their
|
|
|
|
* init. This eliminates a lot of boilerplate. Each driver may only
|
|
|
|
* use this macro once, and calling it replaces device_initcall().
|
|
|
|
*/
|
|
|
|
#define builtin_i2c_driver(__i2c_driver) \
|
|
|
|
builtin_driver(__i2c_driver, i2c_add_driver)
|
|
|
|
|
2009-06-19 08:58:20 -06:00
|
|
|
#endif /* I2C */
|
2012-11-23 04:23:40 -07:00
|
|
|
|
2013-07-11 05:56:15 -06:00
|
|
|
#if IS_ENABLED(CONFIG_OF)
|
|
|
|
/* must call put_device() when done with returned i2c_client device */
|
2019-12-04 05:29:36 -07:00
|
|
|
struct i2c_client *of_find_i2c_device_by_node(struct device_node *node);
|
2013-07-11 05:56:15 -06:00
|
|
|
|
|
|
|
/* must call put_device() when done with returned i2c_adapter device */
|
2019-12-04 05:29:36 -07:00
|
|
|
struct i2c_adapter *of_find_i2c_adapter_by_node(struct device_node *node);
|
2013-07-11 05:56:15 -06:00
|
|
|
|
2015-07-27 08:30:50 -06:00
|
|
|
/* must call i2c_put_adapter() when done with returned i2c_adapter device */
|
|
|
|
struct i2c_adapter *of_get_i2c_adapter_by_node(struct device_node *node);
|
2015-12-08 02:37:46 -07:00
|
|
|
|
2019-12-04 05:29:36 -07:00
|
|
|
const struct of_device_id
|
2016-11-07 05:47:38 -07:00
|
|
|
*i2c_of_match_device(const struct of_device_id *matches,
|
|
|
|
struct i2c_client *client);
|
|
|
|
|
2018-03-25 06:49:03 -06:00
|
|
|
int of_i2c_get_board_info(struct device *dev, struct device_node *node,
|
|
|
|
struct i2c_board_info *info);
|
|
|
|
|
2013-07-11 05:56:15 -06:00
|
|
|
#else
|
|
|
|
|
|
|
|
static inline struct i2c_client *of_find_i2c_device_by_node(struct device_node *node)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline struct i2c_adapter *of_find_i2c_adapter_by_node(struct device_node *node)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
2015-07-27 08:30:50 -06:00
|
|
|
|
|
|
|
static inline struct i2c_adapter *of_get_i2c_adapter_by_node(struct device_node *node)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
2016-11-07 05:47:38 -07:00
|
|
|
|
|
|
|
static inline const struct of_device_id
|
|
|
|
*i2c_of_match_device(const struct of_device_id *matches,
|
|
|
|
struct i2c_client *client)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2018-03-25 06:49:03 -06:00
|
|
|
static inline int of_i2c_get_board_info(struct device *dev,
|
|
|
|
struct device_node *node,
|
|
|
|
struct i2c_board_info *info)
|
|
|
|
{
|
|
|
|
return -ENOTSUPP;
|
|
|
|
}
|
|
|
|
|
2013-07-11 05:56:15 -06:00
|
|
|
#endif /* CONFIG_OF */
|
|
|
|
|
2019-01-09 08:24:55 -07:00
|
|
|
struct acpi_resource;
|
|
|
|
struct acpi_resource_i2c_serialbus;
|
|
|
|
|
2016-08-12 08:02:53 -06:00
|
|
|
#if IS_ENABLED(CONFIG_ACPI)
|
2019-01-09 08:24:55 -07:00
|
|
|
bool i2c_acpi_get_i2c_resource(struct acpi_resource *ares,
|
|
|
|
struct acpi_resource_i2c_serialbus **i2c);
|
2016-08-12 08:02:53 -06:00
|
|
|
u32 i2c_acpi_find_bus_speed(struct device *dev);
|
i2c: core: Add new i2c_acpi_new_device helper function
By default the i2c subsys creates an i2c-client for the first I2cSerialBus
resource of an acpi_device, but some acpi_devices have multiple
I2cSerialBus resources and we may want to instantiate i2c-clients for
the others.
This commit adds a new i2c_acpi_new_device function which can be used to
create an i2c-client for any I2cSerialBus resource of an acpi_device.
Note that the other resources may even be on a different i2c bus, so just
retrieving the client address is not enough.
Here is an example DSDT excerpt from such a device:
Device (WIDR)
{
Name (_HID, "INT33FE" /* XPOWER Battery Device */)
Name (_CID, "INT33FE" /* XPOWER Battery Device */)
Name (_DDN, "WC PMIC Battery Device")
<snip>
Name (RBUF, ResourceTemplate ()
{
I2cSerialBusV2 (0x005E, ControllerInitiated, 0x000186A0,
AddressingMode7Bit, "\\_SB.PCI0.I2C7",
0x00, ResourceConsumer, , Exclusive,
)
I2cSerialBusV2 (0x0036, ControllerInitiated, 0x000186A0,
AddressingMode7Bit, "\\_SB.PCI0.I2C1",
0x00, ResourceConsumer, , Exclusive,
)
I2cSerialBusV2 (0x0022, ControllerInitiated, 0x00061A80,
AddressingMode7Bit, "\\_SB.PCI0.I2C1",
0x00, ResourceConsumer, , Exclusive,
)
I2cSerialBusV2 (0x0054, ControllerInitiated, 0x00061A80,
AddressingMode7Bit, "\\_SB.PCI0.I2C1",
0x00, ResourceConsumer, , Exclusive,
)
GpioInt (Level, ActiveLow, Exclusive, PullNone, 0x0000,
"\\_SB.PCI0.I2C7.PMI5", 0x00, ResourceConsumer, ,
)
{ // Pin list
0x0012
}
GpioInt (Edge, ActiveLow, ExclusiveAndWake, PullNone, 0x0000,
"\\_SB.GPO1", 0x00, ResourceConsumer, ,
)
{ // Pin list
0x0005
}
GpioInt (Level, ActiveLow, Exclusive, PullNone, 0x0000,
"\\_SB.PCI0.I2C7.PMI5", 0x00, ResourceConsumer, ,
)
{ // Pin list
0x0013
}
})
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings
{
Return (RBUF) /* \_SB_.PCI0.I2C7.WIDR.RBUF */
}
<snip>
}
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Reviewed-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
Signed-off-by: Wolfram Sang <wsa@the-dreams.de>
2017-04-04 16:03:33 -06:00
|
|
|
struct i2c_client *i2c_acpi_new_device(struct device *dev, int index,
|
|
|
|
struct i2c_board_info *info);
|
2019-05-28 17:02:32 -06:00
|
|
|
struct i2c_adapter *i2c_acpi_find_adapter_by_handle(acpi_handle handle);
|
2016-08-12 08:02:53 -06:00
|
|
|
#else
|
2019-01-09 08:24:55 -07:00
|
|
|
static inline bool i2c_acpi_get_i2c_resource(struct acpi_resource *ares,
|
|
|
|
struct acpi_resource_i2c_serialbus **i2c)
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
2016-08-12 08:02:53 -06:00
|
|
|
static inline u32 i2c_acpi_find_bus_speed(struct device *dev)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
i2c: core: Add new i2c_acpi_new_device helper function
By default the i2c subsys creates an i2c-client for the first I2cSerialBus
resource of an acpi_device, but some acpi_devices have multiple
I2cSerialBus resources and we may want to instantiate i2c-clients for
the others.
This commit adds a new i2c_acpi_new_device function which can be used to
create an i2c-client for any I2cSerialBus resource of an acpi_device.
Note that the other resources may even be on a different i2c bus, so just
retrieving the client address is not enough.
Here is an example DSDT excerpt from such a device:
Device (WIDR)
{
Name (_HID, "INT33FE" /* XPOWER Battery Device */)
Name (_CID, "INT33FE" /* XPOWER Battery Device */)
Name (_DDN, "WC PMIC Battery Device")
<snip>
Name (RBUF, ResourceTemplate ()
{
I2cSerialBusV2 (0x005E, ControllerInitiated, 0x000186A0,
AddressingMode7Bit, "\\_SB.PCI0.I2C7",
0x00, ResourceConsumer, , Exclusive,
)
I2cSerialBusV2 (0x0036, ControllerInitiated, 0x000186A0,
AddressingMode7Bit, "\\_SB.PCI0.I2C1",
0x00, ResourceConsumer, , Exclusive,
)
I2cSerialBusV2 (0x0022, ControllerInitiated, 0x00061A80,
AddressingMode7Bit, "\\_SB.PCI0.I2C1",
0x00, ResourceConsumer, , Exclusive,
)
I2cSerialBusV2 (0x0054, ControllerInitiated, 0x00061A80,
AddressingMode7Bit, "\\_SB.PCI0.I2C1",
0x00, ResourceConsumer, , Exclusive,
)
GpioInt (Level, ActiveLow, Exclusive, PullNone, 0x0000,
"\\_SB.PCI0.I2C7.PMI5", 0x00, ResourceConsumer, ,
)
{ // Pin list
0x0012
}
GpioInt (Edge, ActiveLow, ExclusiveAndWake, PullNone, 0x0000,
"\\_SB.GPO1", 0x00, ResourceConsumer, ,
)
{ // Pin list
0x0005
}
GpioInt (Level, ActiveLow, Exclusive, PullNone, 0x0000,
"\\_SB.PCI0.I2C7.PMI5", 0x00, ResourceConsumer, ,
)
{ // Pin list
0x0013
}
})
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings
{
Return (RBUF) /* \_SB_.PCI0.I2C7.WIDR.RBUF */
}
<snip>
}
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Reviewed-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
Signed-off-by: Wolfram Sang <wsa@the-dreams.de>
2017-04-04 16:03:33 -06:00
|
|
|
static inline struct i2c_client *i2c_acpi_new_device(struct device *dev,
|
|
|
|
int index, struct i2c_board_info *info)
|
|
|
|
{
|
2020-07-25 08:07:36 -06:00
|
|
|
return ERR_PTR(-ENODEV);
|
i2c: core: Add new i2c_acpi_new_device helper function
By default the i2c subsys creates an i2c-client for the first I2cSerialBus
resource of an acpi_device, but some acpi_devices have multiple
I2cSerialBus resources and we may want to instantiate i2c-clients for
the others.
This commit adds a new i2c_acpi_new_device function which can be used to
create an i2c-client for any I2cSerialBus resource of an acpi_device.
Note that the other resources may even be on a different i2c bus, so just
retrieving the client address is not enough.
Here is an example DSDT excerpt from such a device:
Device (WIDR)
{
Name (_HID, "INT33FE" /* XPOWER Battery Device */)
Name (_CID, "INT33FE" /* XPOWER Battery Device */)
Name (_DDN, "WC PMIC Battery Device")
<snip>
Name (RBUF, ResourceTemplate ()
{
I2cSerialBusV2 (0x005E, ControllerInitiated, 0x000186A0,
AddressingMode7Bit, "\\_SB.PCI0.I2C7",
0x00, ResourceConsumer, , Exclusive,
)
I2cSerialBusV2 (0x0036, ControllerInitiated, 0x000186A0,
AddressingMode7Bit, "\\_SB.PCI0.I2C1",
0x00, ResourceConsumer, , Exclusive,
)
I2cSerialBusV2 (0x0022, ControllerInitiated, 0x00061A80,
AddressingMode7Bit, "\\_SB.PCI0.I2C1",
0x00, ResourceConsumer, , Exclusive,
)
I2cSerialBusV2 (0x0054, ControllerInitiated, 0x00061A80,
AddressingMode7Bit, "\\_SB.PCI0.I2C1",
0x00, ResourceConsumer, , Exclusive,
)
GpioInt (Level, ActiveLow, Exclusive, PullNone, 0x0000,
"\\_SB.PCI0.I2C7.PMI5", 0x00, ResourceConsumer, ,
)
{ // Pin list
0x0012
}
GpioInt (Edge, ActiveLow, ExclusiveAndWake, PullNone, 0x0000,
"\\_SB.GPO1", 0x00, ResourceConsumer, ,
)
{ // Pin list
0x0005
}
GpioInt (Level, ActiveLow, Exclusive, PullNone, 0x0000,
"\\_SB.PCI0.I2C7.PMI5", 0x00, ResourceConsumer, ,
)
{ // Pin list
0x0013
}
})
Method (_CRS, 0, NotSerialized) // _CRS: Current Resource Settings
{
Return (RBUF) /* \_SB_.PCI0.I2C7.WIDR.RBUF */
}
<snip>
}
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Reviewed-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
Signed-off-by: Wolfram Sang <wsa@the-dreams.de>
2017-04-04 16:03:33 -06:00
|
|
|
}
|
2019-05-28 17:02:32 -06:00
|
|
|
static inline struct i2c_adapter *i2c_acpi_find_adapter_by_handle(acpi_handle handle)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
2016-08-12 08:02:53 -06:00
|
|
|
#endif /* CONFIG_ACPI */
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif /* _LINUX_I2C_H */
|