2005-04-16 15:20:36 -07:00
/* ------------------------------------------------------------------------- */
2006-12-10 21:21:31 +01:00
/* */
2005-04-16 15:20:36 -07:00
/* i2c.h - definitions for the i2c-bus interface */
2006-12-10 21:21:31 +01:00
/* */
2005-04-16 15:20:36 -07:00
/* ------------------------------------------------------------------------- */
/* Copyright (C) 1995-2000 Simon G. Vogl
This program is free software ; you can redistribute it and / or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation ; either version 2 of the License , or
( at your option ) any later version .
This program is distributed in the hope that it will be useful ,
but WITHOUT ANY WARRANTY ; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the
GNU General Public License for more details .
You should have received a copy of the GNU General Public License
along with this program ; if not , write to the Free Software
2012-03-26 21:47:19 +02:00
Foundation , Inc . , 51 Franklin Street , Fifth Floor , Boston ,
MA 02110 - 1301 USA . */
2005-04-16 15:20:36 -07:00
/* ------------------------------------------------------------------------- */
2006-04-25 14:14:52 +01:00
/* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi> and
2005-04-16 15:20:36 -07:00
Frodo Looijaard < frodol @ dds . nl > */
# ifndef _LINUX_I2C_H
# define _LINUX_I2C_H
2005-10-22 00:23:27 +02:00
# include <linux/mod_devicetable.h>
2005-04-16 15:20:36 -07:00
# include <linux/device.h> /* for struct device */
2005-10-30 15:03:48 -08:00
# include <linux/sched.h> /* for completion */
2006-01-18 23:16:04 +01:00
# include <linux/mutex.h>
2010-04-13 16:12:28 -07:00
# include <linux/of.h> /* for struct device_node */
2011-10-30 13:47:25 +01:00
# include <linux/swab.h> /* for swab16 */
2012-10-13 10:46:48 +01:00
# include <uapi/linux/i2c.h>
2005-04-16 15:20:36 -07:00
2008-07-14 22:38:35 +02:00
extern struct bus_type i2c_bus_type ;
2010-08-11 18:21:02 +02:00
extern struct device_type i2c_adapter_type ;
2008-07-14 22:38:35 +02:00
2005-04-16 15:20:36 -07:00
/* --- General options ------------------------------------------------ */
struct i2c_msg ;
struct i2c_algorithm ;
struct i2c_adapter ;
struct i2c_client ;
struct i2c_driver ;
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 22:38:36 +02:00
struct i2c_board_info ;
2014-11-18 17:04:53 +01:00
enum i2c_slave_event ;
typedef int ( * i2c_slave_cb_t ) ( struct i2c_client * , enum i2c_slave_event , u8 * ) ;
2005-04-16 15:20:36 -07:00
2011-05-26 13:46:22 -04:00
struct module ;
2009-06-19 16:58:20 +02:00
# if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
2005-04-16 15:20:36 -07:00
/*
* The master routines are the ones normally used to transmit data to devices
2006-12-10 21:21:31 +01: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 15:20:36 -07:00
* transmit an arbitrary number of messages without interruption .
2010-03-02 12:23:49 +01:00
* @ count must be be less than 64 k since msg . len is u16 .
2005-04-16 15:20:36 -07:00
*/
2011-01-10 22:11:23 +01:00
extern int i2c_master_send ( const struct i2c_client * client , const char * buf ,
int count ) ;
extern int i2c_master_recv ( const struct i2c_client * client , char * buf ,
2008-10-22 20:21:32 +02:00
int count ) ;
2005-04-16 15:20:36 -07:00
/* Transfer num messages.
*/
2008-10-22 20:21:32 +02:00
extern int i2c_transfer ( struct i2c_adapter * adap , struct i2c_msg * msgs ,
int num ) ;
2012-06-29 07:47:19 -03:00
/* Unlocked flavor */
extern int __i2c_transfer ( struct i2c_adapter * adap , struct i2c_msg * msgs ,
int num ) ;
2005-04-16 15:20:36 -07: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 21:21:31 +01:00
and probably just as fast .
2005-04-16 15:20:36 -07:00
Note that we use i2c_adapter here , because you do not need a specific
smbus adapter to call this function . */
2008-10-22 20:21:32 +02:00
extern s32 i2c_smbus_xfer ( struct i2c_adapter * adapter , u16 addr ,
unsigned short flags , char read_write , u8 command ,
int size , union i2c_smbus_data * data ) ;
2005-04-16 15:20:36 -07:00
/* Now follow the 'nice' access routines. These also document the calling
2008-07-14 22:38:24 +02:00
conventions of i2c_smbus_xfer . */
2005-04-16 15:20:36 -07:00
2011-01-10 22:11:23 +01:00
extern s32 i2c_smbus_read_byte ( const struct i2c_client * client ) ;
extern s32 i2c_smbus_write_byte ( const struct i2c_client * client , u8 value ) ;
extern s32 i2c_smbus_read_byte_data ( const struct i2c_client * client ,
u8 command ) ;
extern s32 i2c_smbus_write_byte_data ( const struct i2c_client * client ,
2008-10-22 20:21:32 +02:00
u8 command , u8 value ) ;
2011-01-10 22:11:23 +01:00
extern s32 i2c_smbus_read_word_data ( const struct i2c_client * client ,
u8 command ) ;
extern s32 i2c_smbus_write_word_data ( const struct i2c_client * client ,
2008-10-22 20:21:32 +02:00
u8 command , u16 value ) ;
2011-10-30 13:47:25 +01: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 23:26:34 +02:00
/* Returns the number of read bytes */
2011-01-10 22:11:23 +01:00
extern s32 i2c_smbus_read_block_data ( const struct i2c_client * client ,
2007-05-01 23:26:34 +02:00
u8 command , u8 * values ) ;
2011-01-10 22:11:23 +01:00
extern s32 i2c_smbus_write_block_data ( const struct i2c_client * client ,
2008-10-22 20:21:32 +02:00
u8 command , u8 length , const u8 * values ) ;
2005-10-08 00:04:13 +02:00
/* Returns the number of read bytes */
2011-01-10 22:11:23 +01:00
extern s32 i2c_smbus_read_i2c_block_data ( const struct i2c_client * client ,
i2c: Fix the i2c_smbus_read_i2c_block_data() prototype
Let the drivers specify how many bytes they want to read with
i2c_smbus_read_i2c_block_data(). So far, the block count was
hard-coded to I2C_SMBUS_BLOCK_MAX (32), which did not make much sense.
Many driver authors complained about this before, and I believe it's
about time to fix it. Right now, authors have to do technically stupid
things, such as individual byte reads or full-fledged I2C messaging,
to work around the problem. We do not want to encourage that.
I even found that some bus drivers (e.g. i2c-amd8111) already
implemented I2C block read the "right" way, that is, they didn't
follow the old, broken standard. The fact that it was never noticed
before just shows how little i2c_smbus_read_i2c_block_data() was used,
which isn't that surprising given how broken its prototype was so far.
There are some obvious compatiblity considerations:
* This changes the i2c_smbus_read_i2c_block_data() prototype. Users
outside the kernel tree will notice at compilation time, and will
have to update their code.
* User-space has access to i2c_smbus_xfer() directly using i2c-dev, so
the changed expectations would affect tools such as i2cdump. In order
to preserve binary compatibility, we give I2C_SMBUS_I2C_BLOCK_DATA
a new numeric value, and define I2C_SMBUS_I2C_BLOCK_BROKEN with the
old numeric value. When i2c-dev receives a transaction with the
old value, it can convert it to the new format on the fly.
Signed-off-by: Jean Delvare <khali@linux-fr.org>
2007-07-12 14:12:29 +02:00
u8 command , u8 length , u8 * values ) ;
2011-01-10 22:11:23 +01:00
extern s32 i2c_smbus_write_i2c_block_data ( const struct i2c_client * client ,
2006-01-09 15:19:18 +11:00
u8 command , u8 length ,
2006-06-12 21:42:20 +02:00
const u8 * values ) ;
2009-06-19 16:58:20 +02:00
# endif /* I2C */
2005-04-16 15:20:36 -07: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 22:38:36 +02:00
/**
* struct i2c_driver - represent an I2C device driver
* @ class : What kind of i2c device we instantiate ( for detect )
2011-03-20 14:50:53 +01:00
* @ attach_adapter : Callback for bus addition ( deprecated )
2009-06-19 16:58:18 +02:00
* @ probe : Callback for device binding
* @ remove : Callback for device unbinding
2008-08-28 08:33:23 +02:00
* @ shutdown : Callback for device shutdown
2010-08-09 16:37:16 -07:00
* @ alert : Alert callback , for example for the SMBus alert protocol
2008-08-28 08:33:23 +02: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 22:38:36 +02:00
* @ detect : Callback for device detection
2009-12-14 21:17:25 +01: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 22:38:36 +02:00
* @ clients : List of detected clients we created ( for i2c - core use only )
2005-11-26 20:34:05 +01: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 22:38:36 +02:00
*
2012-10-05 22:23:54 +02: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 22:38:36 +02: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 15:20:36 -07:00
*/
struct i2c_driver {
unsigned int class ;
2013-03-09 08:16:44 +00:00
/* Notifies the driver that a new bus has appeared. You should avoid
* using this , it will be removed in a near future .
2005-04-16 15:20:36 -07:00
*/
2011-03-20 14:50:53 +01:00
int ( * attach_adapter ) ( struct i2c_adapter * ) __deprecated ;
2005-04-16 15:20:36 -07:00
2009-06-19 16:58:18 +02:00
/* Standard driver model interfaces */
2008-04-29 23:11:39 +02:00
int ( * probe ) ( struct i2c_client * , const struct i2c_device_id * ) ;
2007-05-01 23:26:30 +02:00
int ( * remove ) ( struct i2c_client * ) ;
2007-05-01 23:26:30 +02:00
2007-02-13 22:09:00 +01:00
/* driver model interfaces that don't relate to enumeration */
void ( * shutdown ) ( struct i2c_client * ) ;
2010-03-02 12:23:42 +01: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 " ) .
*/
void ( * alert ) ( struct i2c_client * , unsigned int data ) ;
2005-04-16 15:20:36 -07:00
/* a ioctl like command that can be used to perform specific functions
* with the device .
*/
2008-10-22 20:21:32 +02:00
int ( * command ) ( struct i2c_client * client , unsigned int cmd , void * arg ) ;
2005-04-16 15:20:36 -07:00
struct device_driver driver ;
2008-04-29 23:11:39 +02: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 22:38:36 +02:00
/* Device detection callback for automatic device creation */
2009-12-14 21:17:23 +01:00
int ( * detect ) ( struct i2c_client * , struct i2c_board_info * ) ;
2009-12-14 21:17:25 +01: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 22:38:36 +02:00
struct list_head clients ;
2005-04-16 15:20:36 -07:00
} ;
# define to_i2c_driver(d) container_of(d, struct i2c_driver, driver)
2007-05-01 23:26:28 +02:00
/**
* struct i2c_client - represent an I2C slave device
2007-07-12 14:12:28 +02:00
* @ flags : I2C_CLIENT_TEN indicates the device uses a ten bit chip address ;
* I2C_CLIENT_PEC indicates it uses SMBus Packet Error Checking
2007-05-01 23:26:28 +02: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 14:12:28 +02:00
* @ adapter : manages the bus segment hosting this I2C device
2007-05-01 23:26:28 +02:00
* @ dev : Driver model device node for the slave .
2007-07-12 14:12:28 +02:00
* @ irq : indicates the IRQ generated by this device ( if any )
2009-06-19 16:58:20 +02:00
* @ detected : member of an i2c_driver . clients list or i2c - core ' s
* userspace_devices list
2014-11-18 17:04:53 +01: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 23:26:28 +02:00
*
* An i2c_client identifies a single device ( i . e . chip ) connected to an
2007-07-12 14:12:28 +02:00
* i2c bus . The behaviour exposed to Linux is defined by the driver
* managing the device .
2005-04-16 15:20:36 -07:00
*/
struct i2c_client {
2007-05-01 23:26:28 +02:00
unsigned short flags ; /* div., see below */
2006-12-10 21:21:31 +01:00
unsigned short addr ; /* chip address - NOTE: 7bit */
2005-04-16 15:20:36 -07:00
/* addresses are stored in the */
2005-07-20 00:02:32 +02:00
/* _LOWER_ 7 bits */
2007-05-01 23:26:28 +02:00
char name [ I2C_NAME_SIZE ] ;
2005-04-16 15:20:36 -07:00
struct i2c_adapter * adapter ; /* the adapter we sit on */
struct device dev ; /* the device structure */
2008-07-01 22:38:18 +02: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 22:38:36 +02:00
struct list_head detected ;
2015-01-26 20:59:31 +01:00
# if IS_ENABLED(CONFIG_I2C_SLAVE)
2014-11-18 17:04:53 +01:00
i2c_slave_cb_t slave_cb ; /* callback for slave mode */
2015-01-26 20:59:31 +01:00
# endif
2005-04-16 15:20:36 -07:00
} ;
# define to_i2c_client(d) container_of(d, struct i2c_client, dev)
2008-01-27 18:14:51 +01:00
extern struct i2c_client * i2c_verify_client ( struct device * dev ) ;
2012-04-17 12:43:33 -06:00
extern struct i2c_adapter * i2c_verify_adapter ( struct device * dev ) ;
2008-01-27 18:14:51 +01:00
2005-07-27 12:43:03 -05:00
static inline struct i2c_client * kobj_to_i2c_client ( struct kobject * kobj )
{
2007-07-12 14:12:28 +02:00
struct device * const dev = container_of ( kobj , struct device , kobj ) ;
return to_i2c_client ( dev ) ;
2005-07-27 12:43:03 -05:00
}
2008-10-22 20:21:31 +02:00
static inline void * i2c_get_clientdata ( const struct i2c_client * dev )
2005-04-16 15:20:36 -07:00
{
2008-10-22 20:21:32 +02:00
return dev_get_drvdata ( & dev - > dev ) ;
2005-04-16 15:20:36 -07:00
}
2008-10-22 20:21:32 +02:00
static inline void i2c_set_clientdata ( struct i2c_client * dev , void * data )
2005-04-16 15:20:36 -07:00
{
2008-10-22 20:21:32 +02:00
dev_set_drvdata ( & dev - > dev , data ) ;
2005-04-16 15:20:36 -07:00
}
2014-11-18 17:04:53 +01:00
/* I2C slave support */
2015-01-26 20:59:31 +01:00
# if IS_ENABLED(CONFIG_I2C_SLAVE)
2014-11-18 17:04:53 +01:00
enum i2c_slave_event {
I2C_SLAVE_REQ_READ_START ,
I2C_SLAVE_REQ_READ_END ,
I2C_SLAVE_REQ_WRITE_START ,
I2C_SLAVE_REQ_WRITE_END ,
I2C_SLAVE_STOP ,
} ;
extern int i2c_slave_register ( struct i2c_client * client , i2c_slave_cb_t slave_cb ) ;
extern int i2c_slave_unregister ( struct i2c_client * client ) ;
static inline int i2c_slave_event ( struct i2c_client * client ,
enum i2c_slave_event event , u8 * val )
{
return client - > slave_cb ( client , event , val ) ;
}
2015-01-26 20:59:31 +01:00
# endif
2014-11-18 17:04:53 +01: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 23:26:31 +02:00
/**
* struct i2c_board_info - template for device creation
2008-05-18 20:49:41 +02: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 23:26:31 +02:00
* @ flags : to initialize i2c_client . flags
* @ addr : stored in i2c_client . addr
* @ platform_data : stored in i2c_client . dev . platform_data
2008-10-22 20:21:33 +02:00
* @ archdata : copied into i2c_client . dev . archdata
2010-08-09 16:37:16 -07:00
* @ of_node : pointer to OpenFirmware device node
2012-11-23 12:23:40 +01:00
* @ acpi_node : ACPI device node
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 23:26:31 +02:00
* @ irq : stored in i2c_client . irq
2007-07-12 14:12:28 +02: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 23:26:31 +02: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 16:58:18 +02: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 ,
* i2c_new_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 23:26:31 +02:00
*/
struct i2c_board_info {
char type [ I2C_NAME_SIZE ] ;
unsigned short flags ;
unsigned short addr ;
void * platform_data ;
2008-10-22 20:21:33 +02:00
struct dev_archdata * archdata ;
2010-04-13 16:12:28 -07:00
struct device_node * of_node ;
2012-11-23 12:23:40 +01:00
struct acpi_dev_node acpi_node ;
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 23:26:31 +02:00
int irq ;
} ;
/**
2008-04-29 23:11:40 +02: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 23:26:31 +02: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 23:11:40 +02: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 23:26:31 +02:00
*/
2008-10-22 20:21:32 +02:00
# define I2C_BOARD_INFO(dev_type, dev_addr) \
2009-04-13 17:02:14 +02: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 23:26:31 +02:00
2009-06-19 16:58:20 +02:00
# if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
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 23:26:31 +02:00
/* Add-on boards should register/unregister their devices; e.g. a board
* with integrated I2C , a config eeprom , sensors , and a codec that ' s
* used in conjunction with the primary hardware .
*/
extern struct i2c_client *
i2c_new_device ( struct i2c_adapter * adap , struct i2c_board_info const * info ) ;
2007-05-01 23:26:31 +02: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 18:20:56 +02: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 23:26:31 +02:00
*/
extern struct i2c_client *
i2c_new_probed_device ( struct i2c_adapter * adap ,
struct i2c_board_info * info ,
2010-08-11 18:20:56 +02:00
unsigned short const * addr_list ,
int ( * probe ) ( struct i2c_adapter * , unsigned short addr ) ) ;
2007-05-01 23:26:31 +02:00
2010-08-11 18:20:57 +02:00
/* Common custom probe functions */
extern int i2c_probe_func_quick_read ( struct i2c_adapter * , unsigned short addr ) ;
2008-01-27 18:14:52 +01:00
/* For devices that use several addresses, use i2c_new_dummy() to make
* client handles for the extra addresses .
*/
extern struct i2c_client *
2008-05-11 20:37:06 +02:00
i2c_new_dummy ( struct i2c_adapter * adap , u16 address ) ;
2008-01-27 18:14:52 +01: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 23:26:31 +02:00
extern void i2c_unregister_device ( struct i2c_client * ) ;
2009-06-19 16:58:20 +02: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 23:26:31 +02: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 20:03:42 +01:00
# ifdef CONFIG_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 23:26:31 +02:00
extern int
2008-10-22 20:21:32 +02:00
i2c_register_board_info ( int busnum , struct i2c_board_info const * info ,
unsigned n ) ;
2008-02-24 20:03:42 +01:00
# else
static inline int
2008-10-22 20:21:32 +02:00
i2c_register_board_info ( int busnum , struct i2c_board_info const * info ,
unsigned n )
2008-02-24 20:03:42 +01:00
{
return 0 ;
}
2009-06-19 16:58:20 +02: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 23:26:31 +02:00
2014-01-26 16:05:36 +00: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 .
* @ 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 .
* @ functionality : Return the flags that this algorithm / adapter pair supports
* from the I2C_FUNC_ * flags .
2014-11-18 17:04:53 +01: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 16:05:36 +00:00
*
2005-04-16 15:20:36 -07: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 16:05:36 +00:00
*
* The return codes from the @ master_xfer field should indicate the type of
2014-10-22 00:00:14 +09:00
* error code that occurred during the transfer , as documented in the kernel
2014-01-26 16:05:36 +00:00
* Documentation file Documentation / i2c / fault - codes .
2005-04-16 15:20:36 -07:00
*/
struct i2c_algorithm {
/* If an adapter algorithm can't do I2C-level access, set master_xfer
2006-12-10 21:21:31 +01:00
to NULL . If an adapter algorithm can do SMBus access , set
2005-04-16 15:20:36 -07:00
smbus_xfer . If set to NULL , the SMBus protocol is simulated
using common I2C messages */
2006-07-01 17:12:53 +02:00
/* master_xfer should return the number of messages successfully
processed , or a negative value on error */
2008-10-22 20:21:32 +02:00
int ( * master_xfer ) ( struct i2c_adapter * adap , struct i2c_msg * msgs ,
int num ) ;
2006-12-10 21:21:31 +01:00
int ( * smbus_xfer ) ( struct i2c_adapter * adap , u16 addr ,
2008-10-22 20:21:32 +02:00
unsigned short flags , char read_write ,
u8 command , int size , union i2c_smbus_data * data ) ;
2005-04-16 15:20:36 -07:00
/* To determine what the adapter supports */
u32 ( * functionality ) ( struct i2c_adapter * ) ;
2014-11-18 17:04:53 +01:00
2015-01-26 20:59:31 +01:00
# if IS_ENABLED(CONFIG_I2C_SLAVE)
2014-11-18 17:04:53 +01:00
int ( * reg_slave ) ( struct i2c_client * client ) ;
int ( * unreg_slave ) ( struct i2c_client * client ) ;
2015-01-26 20:59:31 +01:00
# endif
2005-04-16 15:20:36 -07:00
} ;
2012-02-28 18:26:31 +05:30
/**
* struct i2c_bus_recovery_info - I2C bus recovery information
* @ recover_bus : Recover routine . Either pass driver ' s recover_bus ( ) routine , or
* i2c_generic_scl_recovery ( ) or i2c_generic_gpio_recovery ( ) .
* @ get_scl : This gets current value of SCL line . Mandatory for generic SCL
* recovery . Used internally for generic GPIO recovery .
* @ set_scl : This sets / clears SCL line . Mandatory for generic SCL recovery . Used
* internally for generic GPIO recovery .
* @ get_sda : This gets current value of SDA line . Optional for generic SCL
* recovery . Used internally , if sda_gpio is a valid GPIO , for generic GPIO
* recovery .
* @ 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 .
* @ scl_gpio : gpio number of the SCL line . Only required for GPIO recovery .
* @ sda_gpio : gpio number of the SDA line . Only required for GPIO recovery .
*/
struct i2c_bus_recovery_info {
int ( * recover_bus ) ( struct i2c_adapter * ) ;
int ( * get_scl ) ( struct i2c_adapter * ) ;
void ( * set_scl ) ( struct i2c_adapter * , int val ) ;
int ( * get_sda ) ( struct i2c_adapter * ) ;
void ( * prepare_recovery ) ( struct i2c_bus_recovery_info * bri ) ;
void ( * unprepare_recovery ) ( struct i2c_bus_recovery_info * bri ) ;
/* gpio recovery */
int scl_gpio ;
int sda_gpio ;
} ;
int i2c_recover_bus ( struct i2c_adapter * adap ) ;
/* Generic recovery routines */
int i2c_generic_gpio_recovery ( struct i2c_adapter * adap ) ;
int i2c_generic_scl_recovery ( struct i2c_adapter * adap ) ;
2015-01-05 15:35:39 +01: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 )
2005-04-16 15:20:36 -07: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 20:21:30 +02:00
unsigned int class ; /* classes to allow probing for */
2006-09-03 22:37:11 +02:00
const struct i2c_algorithm * algo ; /* the algorithm to access the bus */
2005-04-16 15:20:36 -07:00
void * algo_data ;
/* data fields that are valid for all devices */
2009-12-06 17:06:22 +01:00
struct rt_mutex bus_lock ;
2005-04-16 15:20:36 -07:00
2009-02-24 19:19:49 +01:00
int timeout ; /* in jiffies */
2005-04-16 15:20:36 -07:00
int retries ;
struct device dev ; /* the adapter device */
int nr ;
2007-05-01 23:26:28 +02:00
char name [ 48 ] ;
2005-04-16 15:20:36 -07:00
struct completion dev_released ;
2010-05-04 11:09:28 +02:00
2010-08-11 18:21:01 +02:00
struct mutex userspace_clients_lock ;
2010-05-04 11:09:28 +02:00
struct list_head userspace_clients ;
2012-02-28 18:26:31 +05:30
struct i2c_bus_recovery_info * bus_recovery_info ;
2015-01-05 15:35:39 +01:00
const struct i2c_adapter_quirks * quirks ;
2005-04-16 15:20:36 -07:00
} ;
2007-05-01 23:26:28 +02:00
# define to_i2c_adapter(d) container_of(d, struct i2c_adapter, dev)
2005-04-16 15:20:36 -07:00
2008-10-22 20:21:31 +02:00
static inline void * i2c_get_adapdata ( const struct i2c_adapter * dev )
2005-04-16 15:20:36 -07:00
{
2008-10-22 20:21:32 +02:00
return dev_get_drvdata ( & dev - > dev ) ;
2005-04-16 15:20:36 -07:00
}
2008-10-22 20:21:32 +02:00
static inline void i2c_set_adapdata ( struct i2c_adapter * dev , void * data )
2005-04-16 15:20:36 -07:00
{
2008-10-22 20:21:32 +02:00
dev_set_drvdata ( & dev - > dev , data ) ;
2005-04-16 15:20:36 -07:00
}
2010-10-24 18:16:57 +02:00
static inline struct i2c_adapter *
i2c_parent_is_i2c_adapter ( const struct i2c_adapter * adapter )
2010-08-11 18:21:02 +02:00
{
2014-01-13 14:29:04 -07:00
# if IS_ENABLED(CONFIG_I2C_MUX)
2010-10-24 18:16:57 +02:00
struct device * parent = adapter - > dev . parent ;
if ( parent ! = NULL & & parent - > type = = & i2c_adapter_type )
return to_i2c_adapter ( parent ) ;
else
2013-06-26 10:56:35 +03:00
# endif
2010-10-24 18:16:57 +02:00
return NULL ;
2010-08-11 18:21:02 +02:00
}
2011-03-20 14:50:52 +01:00
int i2c_for_each_dev ( void * data , int ( * fn ) ( struct device * , void * ) ) ;
2010-08-11 18:20:58 +02:00
/* Adapter locking functions, exported for shared pin cases */
void i2c_lock_adapter ( struct i2c_adapter * ) ;
void i2c_unlock_adapter ( struct i2c_adapter * ) ;
2009-11-07 13:10:46 +01:00
2005-04-16 15:20:36 -07:00
/*flags for the client struct: */
2007-10-13 23:56:29 +02: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_WAKE 0x80 /* for board_info; true iff can wake */
2012-07-24 14:13:59 +02:00
# define I2C_CLIENT_SCCB 0x9000 /* Use Omnivision SCCB protocol */
/* Must match I2C_M_STOP|IGNORE_NAK */
2005-04-16 15:20:36 -07:00
/* i2c adapter classes (bitmask) */
# define I2C_CLASS_HWMON (1<<0) /* lm_sensors, ... */
2008-07-14 22:38:28 +02:00
# define I2C_CLASS_DDC (1<<3) /* DDC bus on graphics adapters */
2011-05-25 20:43:32 +02:00
# define I2C_CLASS_SPD (1<<7) /* Memory modules */
2014-02-10 11:03:56 +01:00
# define I2C_CLASS_DEPRECATED (1<<8) /* Warn users that adapter will stop using classes */
2005-04-16 15:20:36 -07: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 16:58:21 +02: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 15:20:36 -07:00
/* ----- functions exported by i2c.o */
/* administration...
*/
2009-06-19 16:58:20 +02:00
# if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
2005-04-16 15:20:36 -07:00
extern int i2c_add_adapter ( struct i2c_adapter * ) ;
2013-03-09 08:16:47 +00:00
extern void i2c_del_adapter ( struct i2c_adapter * ) ;
2007-05-01 23:26:31 +02:00
extern int i2c_add_numbered_adapter ( struct i2c_adapter * ) ;
2005-04-16 15:20:36 -07:00
2005-12-06 15:33:15 -08:00
extern int i2c_register_driver ( struct module * , struct i2c_driver * ) ;
2007-05-01 23:26:32 +02:00
extern void i2c_del_driver ( struct i2c_driver * ) ;
2005-04-16 15:20:36 -07:00
2011-05-27 09:02:11 -04: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 15:33:15 -08:00
2008-01-27 18:14:48 +01:00
extern struct i2c_client * i2c_use_client ( struct i2c_client * client ) ;
extern void i2c_release_client ( struct i2c_client * client ) ;
2005-04-16 15:20:36 -07:00
/* call the i2c_client->command() of all attached clients with
* the given arguments */
extern void i2c_clients_command ( struct i2c_adapter * adap ,
unsigned int cmd , void * arg ) ;
2011-03-20 14:50:52 +01:00
extern struct i2c_adapter * i2c_get_adapter ( int nr ) ;
2005-04-16 15:20:36 -07:00
extern void i2c_put_adapter ( struct i2c_adapter * adap ) ;
/* 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 ;
}
2008-10-22 20:21:32 +02:00
/* Return the adapter number for a specific adapter */
2005-07-28 23:09:40 +02:00
static inline int i2c_adapter_id ( struct i2c_adapter * adap )
{
return adap - > nr ;
}
2011-11-16 10:13:36 +01:00
/**
* module_i2c_driver ( ) - Helper macro for registering a I2C driver
* @ __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 )
2009-06-19 16:58:20 +02:00
# endif /* I2C */
2012-11-23 12:23:40 +01:00
2013-07-11 12:56:15 +01:00
# if IS_ENABLED(CONFIG_OF)
/* must call put_device() when done with returned i2c_client device */
extern struct i2c_client * of_find_i2c_device_by_node ( struct device_node * node ) ;
/* must call put_device() when done with returned i2c_adapter device */
extern struct i2c_adapter * of_find_i2c_adapter_by_node ( struct device_node * node ) ;
# 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 ;
}
# endif /* CONFIG_OF */
2005-04-16 15:20:36 -07:00
# endif /* _LINUX_I2C_H */