1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
|
/*
* 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 */
|
