/*
* i2c-slave.h - definitions for the i2c-slave-bus interface
*
* Copyright (c) 2009-2011, NVIDIA Corporation.
*
* 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 Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
/* ------------------------------------------------------------------------- */
#ifndef _LINUX_I2C_SLAVE_H
#define _LINUX_I2C_SLAVE_H
#include <linux/types.h>
#ifdef __KERNEL__
/* --- General options ------------------------------------------------ */
struct i2c_client;
struct i2c_slave_algorithm;
struct i2c_slave_adapter;
#if defined(CONFIG_I2C_SLAVE) && defined(CONFIG_I2C)
/**
* i2c_slave_send - Sends data to master. When master issues a read cycle, the
* data is sent by the slave.
* This function copies the client data into the slave tx buffer and return to
* client. This is not a blocking call. Data will be sent to master later once
* slave got the master-ready cycle transfer.
* if there is no sufficient space to write the client buffer, it will return
* error. it will not write partial data.
* @client: Handle to i2c-slave client.
* @buf: Data that will be written to the master
* @count: How many bytes to write.
*
* Returns negative errno, or else the number of bytes written.
*/
extern int i2c_slave_send(struct i2c_client *client, const char *buf,
int count);
/**
* i2c_slave_get_tx_status - Get amount of data available in tx buffer. If there
* is still data in tx buffer then wait for given time to transfer complete
* for a give timeout.
* @client: Handle to i2c-slave client.
* @timeout_ms: Time to wait for transfer to complete.
*
* Returns negative errno, or else the number of bytes remaining in tx buffer.
*/
extern int i2c_slave_get_tx_status(struct i2c_client *client, int timeout_ms);
/**
* i2c_slave_recv - Receive data from master. The data received from master is
* stored on slave rx buffer. When this api will be called, the data will be
* copied from the slave rx buffer to client buffer. If requested amount (count)
* of data is not available then it will wait for either min_count to be receive
* or timeout whatever first.
*
* if timeout_ms = 0, then wait for min_count data to be read.
* if timoue_ms non zero then wait for the data till timeout happen.
* @client: Handle to i2c-slave client.
* @buf: Data that will be read from the master
* @count: How many bytes to read.
* @min_count: Block till read min_count of data.
* @timeout_ms: Time to wait for read to be complete.
*
* Returns negative errno, or else the number of bytes read.
*/
extern int i2c_slave_recv(struct i2c_client *client, char *buf, int count,
int min_count, int timeout_ms);
/**
* i2c_slave_start - Start the i2c slave to receive/transmit data.
* After this i2c controller starts responding master.
* The dummy-char will send to master if there is no data to send on slave tx
* buffer.
* @client: Handle to i2c-slave client.
* @dummy_char: Data which will be send to master if there is no data to be send
* in slave tx buffer.
*
* Returns negative errno, or else 0 for success.
*/
extern int i2c_slave_start(struct i2c_client *client, unsigned char dummy_char);
/**
* i2c_slave_stop - Stop slave to receive/transmit data.
* After this i2c controller stops responding master.
* @client: Handle to i2c-slave client.
* @is_buffer_clear: Reset the tx and rx slave buffer or not.
*/
extern void i2c_slave_stop(struct i2c_client *client, int is_buffer_clear);
/**
* i2c_slave_flush_buffer - Flush the receive and transmit buffer.
* @client: Handle to i2c-slave client.
* @is_flush_tx_buffer: Reset the tx slave buffer or not.
* @is_flush_rx_buffer: Reset the rx slave buffer or not.
*
* Returns negative errno, or else 0 for success.
*/
extern int i2c_slave_flush_buffer(struct i2c_client *client,
int is_flush_tx_buffer, int is_flush_rx_buffer);
/**
* i2c_slave_get_nack_cycle - Get the number of master read cycle on which
* dummy char sent. This is the way to find that how much cycle slave sent the
* NACK packet.
*
* @client: Handle to i2c-slave client.
* @is_cout_reset: Reset the nack count or not.
*
* Returns negative errno, or else 0 for success.
*/
extern int i2c_slave_get_nack_cycle(struct i2c_client *client,
int is_cout_reset);
/**
* i2c_add_slave_adapter - Add slave adapter.
*
* @slv_adap: Slave adapter.
* @force_nr: Adapter number.
*
* Returns negative errno, or else 0 for success.
*/
extern int i2c_add_slave_adapter(struct i2c_slave_adapter *slv_adap,
bool force_nr);
/**
* i2c_del_slave_adapter - Delete slave adapter.
*
* @slv_adap: Slave adapter.
*
* Returns negative errno, or else 0 for success.
*/
extern int i2c_del_slave_adapter(struct i2c_slave_adapter *slv_adap);
#endif /* I2C_SLAVE */
/*
* i2c_slave_adapter is the structure used to identify a physical i2c bus along
* with the access algorithms necessary to access it.
*/
struct i2c_slave_adapter {
struct module *owner;
unsigned int id;
unsigned int class; /* classes to allow probing for */
/* the algorithm to access the i2c-slave bus */
const struct i2c_slave_algorithm *slv_algo;
void *algo_data;
void *parent_data;
/* data fields that are valid for all devices */
u8 level; /* nesting level for lockdep */
struct mutex bus_lock;
int timeout; /* in jiffies */
int retries;
struct device *dev; /* the adapter device */
struct device *parent_dev; /* the adapter device */
int nr;
char name[48];
struct completion dev_released;
};
static inline void *i2c_get_slave_adapdata(const struct i2c_slave_adapter *dev)
{
return dev_get_drvdata(dev->dev);
}
static inline void i2c_set_slave_adapdata(struct i2c_slave_adapter *dev,
void *data)
{
dev_set_drvdata(dev->dev, data);
}
/*
* The following struct are for those who like to implement new i2c slave
* bus drivers:
* i2c_slave_algorithm is the interface to a class of hardware solutions which
* can be addressed using the same bus algorithms.
*/
struct i2c_slave_algorithm {
/* Start the slave to receive/transmit data.
* The dummy-char will send to master if there is no data to send on
* slave tx buffer.
*/
int (*slave_start)(struct i2c_slave_adapter *slv_adap, int addr,
int is_ten_bit_addr, unsigned char dummy_char);
/* Stop slave to receive/transmit data.
* Required information to reset the slave rx and tx buffer to reset
* or not.
*/
void (*slave_stop)(struct i2c_slave_adapter *slv_adap,
int is_buffer_clear);
/*
* Send data to master. The data will be copied on the slave tx buffer
* and will send to master once master initiates the master-read cycle.
* Function will return immediately once the buffer copied into slave
* tx buffer.
* Client will not wait till data is sent to master.
* This function will not copy data partially. If sufficient space is
* not available, it will return error.
*/
int (*slave_send)(struct i2c_slave_adapter *slv_adap, const char *buf,
int count);
/*
* Get amount of data available in tx buffer. If there is still data in
* tx buffer wait for given time to get slave tx buffer emptied.
* returns number of data available in slave tx buffer.
*/
int (*slave_get_tx_status)(struct i2c_slave_adapter *slv_adap,
int timeout_ms);
/*
* Receive data to master. The data received from master is stored on
* slave rx buffer. When this api will be called, the data will be
* coped from the slave rx buffer to client buffer. If requested (count)
* data is not available then it will wait for either min_count to be
* receive or timeout whatever first.
*
* if timeout_ms = 0, then wait for min_count data to be read.
* if timoue_ms non zero then wait for the data till timeout happen.
* returns number of bytes read as positive integer otherwise error.
*/
int (*slave_recv)(struct i2c_slave_adapter *slv_adap, char *buf,
int count, int min_count, int timeout_ms);
/* Flush the receive and transmit buffer.
*/
int (*slave_flush_buffer)(struct i2c_slave_adapter *slv_adap,
int is_flush_tx_buffer, int is_flush_rx_buffer);
/* Get the number of dummy char cycle.
* Get the number of master read cycle on which dummy character has
* been sent.
* This can be treat as NACK cycle from slave side.
* Pass option whether count need to be reset or not.
*/
int (*slave_get_nack_cycle)(struct i2c_slave_adapter *slv_adap,
int is_cout_reset);
};
#endif /* __KERNEL__ */
#endif /* _LINUX_I2C_SLAVE_H */