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#include <linux/kernel.h>
30#include <linux/sched/signal.h>
31
32#include "solo6x10.h"
33
34u8 solo_i2c_readbyte(struct solo_dev *solo_dev, int id, u8 addr, u8 off)
35{
36 struct i2c_msg msgs[2];
37 u8 data;
38
39 msgs[0].flags = 0;
40 msgs[0].addr = addr;
41 msgs[0].len = 1;
42 msgs[0].buf = &off;
43
44 msgs[1].flags = I2C_M_RD;
45 msgs[1].addr = addr;
46 msgs[1].len = 1;
47 msgs[1].buf = &data;
48
49 i2c_transfer(&solo_dev->i2c_adap[id], msgs, 2);
50
51 return data;
52}
53
54void solo_i2c_writebyte(struct solo_dev *solo_dev, int id, u8 addr,
55 u8 off, u8 data)
56{
57 struct i2c_msg msgs;
58 u8 buf[2];
59
60 buf[0] = off;
61 buf[1] = data;
62 msgs.flags = 0;
63 msgs.addr = addr;
64 msgs.len = 2;
65 msgs.buf = buf;
66
67 i2c_transfer(&solo_dev->i2c_adap[id], &msgs, 1);
68}
69
70static void solo_i2c_flush(struct solo_dev *solo_dev, int wr)
71{
72 u32 ctrl;
73
74 ctrl = SOLO_IIC_CH_SET(solo_dev->i2c_id);
75
76 if (solo_dev->i2c_state == IIC_STATE_START)
77 ctrl |= SOLO_IIC_START;
78
79 if (wr) {
80 ctrl |= SOLO_IIC_WRITE;
81 } else {
82 ctrl |= SOLO_IIC_READ;
83 if (!(solo_dev->i2c_msg->flags & I2C_M_NO_RD_ACK))
84 ctrl |= SOLO_IIC_ACK_EN;
85 }
86
87 if (solo_dev->i2c_msg_ptr == solo_dev->i2c_msg->len)
88 ctrl |= SOLO_IIC_STOP;
89
90 solo_reg_write(solo_dev, SOLO_IIC_CTRL, ctrl);
91}
92
93static void solo_i2c_start(struct solo_dev *solo_dev)
94{
95 u32 addr = solo_dev->i2c_msg->addr << 1;
96
97 if (solo_dev->i2c_msg->flags & I2C_M_RD)
98 addr |= 1;
99
100 solo_dev->i2c_state = IIC_STATE_START;
101 solo_reg_write(solo_dev, SOLO_IIC_TXD, addr);
102 solo_i2c_flush(solo_dev, 1);
103}
104
105static void solo_i2c_stop(struct solo_dev *solo_dev)
106{
107 solo_irq_off(solo_dev, SOLO_IRQ_IIC);
108 solo_reg_write(solo_dev, SOLO_IIC_CTRL, 0);
109 solo_dev->i2c_state = IIC_STATE_STOP;
110 wake_up(&solo_dev->i2c_wait);
111}
112
113static int solo_i2c_handle_read(struct solo_dev *solo_dev)
114{
115prepare_read:
116 if (solo_dev->i2c_msg_ptr != solo_dev->i2c_msg->len) {
117 solo_i2c_flush(solo_dev, 0);
118 return 0;
119 }
120
121 solo_dev->i2c_msg_ptr = 0;
122 solo_dev->i2c_msg++;
123 solo_dev->i2c_msg_num--;
124
125 if (solo_dev->i2c_msg_num == 0) {
126 solo_i2c_stop(solo_dev);
127 return 0;
128 }
129
130 if (!(solo_dev->i2c_msg->flags & I2C_M_NOSTART)) {
131 solo_i2c_start(solo_dev);
132 } else {
133 if (solo_dev->i2c_msg->flags & I2C_M_RD)
134 goto prepare_read;
135 else
136 solo_i2c_stop(solo_dev);
137 }
138
139 return 0;
140}
141
142static int solo_i2c_handle_write(struct solo_dev *solo_dev)
143{
144retry_write:
145 if (solo_dev->i2c_msg_ptr != solo_dev->i2c_msg->len) {
146 solo_reg_write(solo_dev, SOLO_IIC_TXD,
147 solo_dev->i2c_msg->buf[solo_dev->i2c_msg_ptr]);
148 solo_dev->i2c_msg_ptr++;
149 solo_i2c_flush(solo_dev, 1);
150 return 0;
151 }
152
153 solo_dev->i2c_msg_ptr = 0;
154 solo_dev->i2c_msg++;
155 solo_dev->i2c_msg_num--;
156
157 if (solo_dev->i2c_msg_num == 0) {
158 solo_i2c_stop(solo_dev);
159 return 0;
160 }
161
162 if (!(solo_dev->i2c_msg->flags & I2C_M_NOSTART)) {
163 solo_i2c_start(solo_dev);
164 } else {
165 if (solo_dev->i2c_msg->flags & I2C_M_RD)
166 solo_i2c_stop(solo_dev);
167 else
168 goto retry_write;
169 }
170
171 return 0;
172}
173
174int solo_i2c_isr(struct solo_dev *solo_dev)
175{
176 u32 status = solo_reg_read(solo_dev, SOLO_IIC_CTRL);
177 int ret = -EINVAL;
178
179
180 if (CHK_FLAGS(status, SOLO_IIC_STATE_TRNS | SOLO_IIC_STATE_SIG_ERR)
181 || solo_dev->i2c_id < 0) {
182 solo_i2c_stop(solo_dev);
183 return -ENXIO;
184 }
185
186 switch (solo_dev->i2c_state) {
187 case IIC_STATE_START:
188 if (solo_dev->i2c_msg->flags & I2C_M_RD) {
189 solo_dev->i2c_state = IIC_STATE_READ;
190 ret = solo_i2c_handle_read(solo_dev);
191 break;
192 }
193
194 solo_dev->i2c_state = IIC_STATE_WRITE;
195
196 case IIC_STATE_WRITE:
197 ret = solo_i2c_handle_write(solo_dev);
198 break;
199
200 case IIC_STATE_READ:
201 solo_dev->i2c_msg->buf[solo_dev->i2c_msg_ptr] =
202 solo_reg_read(solo_dev, SOLO_IIC_RXD);
203 solo_dev->i2c_msg_ptr++;
204
205 ret = solo_i2c_handle_read(solo_dev);
206 break;
207
208 default:
209 solo_i2c_stop(solo_dev);
210 }
211
212 return ret;
213}
214
215static int solo_i2c_master_xfer(struct i2c_adapter *adap,
216 struct i2c_msg msgs[], int num)
217{
218 struct solo_dev *solo_dev = adap->algo_data;
219 unsigned long timeout;
220 int ret;
221 int i;
222 DEFINE_WAIT(wait);
223
224 for (i = 0; i < SOLO_I2C_ADAPTERS; i++) {
225 if (&solo_dev->i2c_adap[i] == adap)
226 break;
227 }
228
229 if (i == SOLO_I2C_ADAPTERS)
230 return num;
231
232 mutex_lock(&solo_dev->i2c_mutex);
233 solo_dev->i2c_id = i;
234 solo_dev->i2c_msg = msgs;
235 solo_dev->i2c_msg_num = num;
236 solo_dev->i2c_msg_ptr = 0;
237
238 solo_reg_write(solo_dev, SOLO_IIC_CTRL, 0);
239 solo_irq_on(solo_dev, SOLO_IRQ_IIC);
240 solo_i2c_start(solo_dev);
241
242 timeout = HZ / 2;
243
244 for (;;) {
245 prepare_to_wait(&solo_dev->i2c_wait, &wait,
246 TASK_INTERRUPTIBLE);
247
248 if (solo_dev->i2c_state == IIC_STATE_STOP)
249 break;
250
251 timeout = schedule_timeout(timeout);
252 if (!timeout)
253 break;
254
255 if (signal_pending(current))
256 break;
257 }
258
259 finish_wait(&solo_dev->i2c_wait, &wait);
260 ret = num - solo_dev->i2c_msg_num;
261 solo_dev->i2c_state = IIC_STATE_IDLE;
262 solo_dev->i2c_id = -1;
263
264 mutex_unlock(&solo_dev->i2c_mutex);
265
266 return ret;
267}
268
269static u32 solo_i2c_functionality(struct i2c_adapter *adap)
270{
271 return I2C_FUNC_I2C;
272}
273
274static const struct i2c_algorithm solo_i2c_algo = {
275 .master_xfer = solo_i2c_master_xfer,
276 .functionality = solo_i2c_functionality,
277};
278
279int solo_i2c_init(struct solo_dev *solo_dev)
280{
281 int i;
282 int ret;
283
284 solo_reg_write(solo_dev, SOLO_IIC_CFG,
285 SOLO_IIC_PRESCALE(8) | SOLO_IIC_ENABLE);
286
287 solo_dev->i2c_id = -1;
288 solo_dev->i2c_state = IIC_STATE_IDLE;
289 init_waitqueue_head(&solo_dev->i2c_wait);
290 mutex_init(&solo_dev->i2c_mutex);
291
292 for (i = 0; i < SOLO_I2C_ADAPTERS; i++) {
293 struct i2c_adapter *adap = &solo_dev->i2c_adap[i];
294
295 snprintf(adap->name, I2C_NAME_SIZE, "%s I2C %d",
296 SOLO6X10_NAME, i);
297 adap->algo = &solo_i2c_algo;
298 adap->algo_data = solo_dev;
299 adap->retries = 1;
300 adap->dev.parent = &solo_dev->pdev->dev;
301
302 ret = i2c_add_adapter(adap);
303 if (ret) {
304 adap->algo_data = NULL;
305 break;
306 }
307 }
308
309 if (ret) {
310 for (i = 0; i < SOLO_I2C_ADAPTERS; i++) {
311 if (!solo_dev->i2c_adap[i].algo_data)
312 break;
313 i2c_del_adapter(&solo_dev->i2c_adap[i]);
314 solo_dev->i2c_adap[i].algo_data = NULL;
315 }
316 return ret;
317 }
318
319 return 0;
320}
321
322void solo_i2c_exit(struct solo_dev *solo_dev)
323{
324 int i;
325
326 for (i = 0; i < SOLO_I2C_ADAPTERS; i++) {
327 if (!solo_dev->i2c_adap[i].algo_data)
328 continue;
329 i2c_del_adapter(&solo_dev->i2c_adap[i]);
330 solo_dev->i2c_adap[i].algo_data = NULL;
331 }
332}
333
