?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
treewide: remove redundant IS_ERR() before error code check
[linux/fpc-iii.git] / drivers / i2c / busses / i2c-digicolor.c
blob3adf72540db136b8c2ea235066e852e0068be64f
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * I2C bus driver for Conexant Digicolor SoCs
4 *
5 * Author: Baruch Siach <baruch@tkos.co.il>
6 *
7 * Copyright (C) 2015 Paradox Innovation Ltd.
8 */
9
10 #include <linux/clk.h>
11 #include <linux/completion.h>
12 #include <linux/delay.h>
13 #include <linux/i2c.h>
14 #include <linux/interrupt.h>
15 #include <linux/io.h>
16 #include <linux/kernel.h>
17 #include <linux/module.h>
18 #include <linux/of.h>
19 #include <linux/platform_device.h>
20
21 #define DEFAULT_FREQ 100000
22 #define TIMEOUT_MS 100
23
24 #define II_CONTROL 0x0
25 #define II_CONTROL_LOCAL_RESET BIT(0)
26
27 #define II_CLOCKTIME 0x1
28
29 #define II_COMMAND 0x2
30 #define II_CMD_START 1
31 #define II_CMD_RESTART 2
32 #define II_CMD_SEND_ACK 3
33 #define II_CMD_GET_ACK 6
34 #define II_CMD_GET_NOACK 7
35 #define II_CMD_STOP 10
36 #define II_COMMAND_GO BIT(7)
37 #define II_COMMAND_COMPLETION_STATUS(r) (((r) >> 5) & 3)
38 #define II_CMD_STATUS_NORMAL 0
39 #define II_CMD_STATUS_ACK_GOOD 1
40 #define II_CMD_STATUS_ACK_BAD 2
41 #define II_CMD_STATUS_ABORT 3
42
43 #define II_DATA 0x3
44 #define II_INTFLAG_CLEAR 0x8
45 #define II_INTENABLE 0xa
46
47 struct dc_i2c {
48 struct i2c_adapter adap;
49 struct device *dev;
50 void __iomem *regs;
51 struct clk *clk;
52 unsigned int frequency;
53
54 struct i2c_msg *msg;
55 unsigned int msgbuf_ptr;
56 int last;
57 spinlock_t lock;
58 struct completion done;
59 int state;
60 int error;
61 };
62
63 enum {
64 STATE_IDLE,
65 STATE_START,
66 STATE_ADDR,
67 STATE_WRITE,
68 STATE_READ,
69 STATE_STOP,
70 };
71
72 static void dc_i2c_cmd(struct dc_i2c *i2c, u8 cmd)
73 {
74 writeb_relaxed(cmd | II_COMMAND_GO, i2c->regs + II_COMMAND);
75 }
76
77 static u8 dc_i2c_addr_cmd(struct i2c_msg *msg)
78 {
79 u8 addr = (msg->addr & 0x7f) << 1;
80
81 if (msg->flags & I2C_M_RD)
82 addr |= 1;
83
84 return addr;
85 }
86
87 static void dc_i2c_data(struct dc_i2c *i2c, u8 data)
88 {
89 writeb_relaxed(data, i2c->regs + II_DATA);
90 }
91
92 static void dc_i2c_write_byte(struct dc_i2c *i2c, u8 byte)
93 {
94 dc_i2c_data(i2c, byte);
95 dc_i2c_cmd(i2c, II_CMD_SEND_ACK);
96 }
97
98 static void dc_i2c_write_buf(struct dc_i2c *i2c)
99 {
100 dc_i2c_write_byte(i2c, i2c->msg->buf[i2c->msgbuf_ptr++]);
101 }
102
103 static void dc_i2c_next_read(struct dc_i2c *i2c)
104 {
105 bool last = (i2c->msgbuf_ptr + 1 == i2c->msg->len);
106
107 dc_i2c_cmd(i2c, last ? II_CMD_GET_NOACK : II_CMD_GET_ACK);
108 }
109
110 static void dc_i2c_stop(struct dc_i2c *i2c)
111 {
112 i2c->state = STATE_STOP;
113 if (i2c->last)
114 dc_i2c_cmd(i2c, II_CMD_STOP);
115 else
116 complete(&i2c->done);
117 }
118
119 static u8 dc_i2c_read_byte(struct dc_i2c *i2c)
120 {
121 return readb_relaxed(i2c->regs + II_DATA);
122 }
123
124 static void dc_i2c_read_buf(struct dc_i2c *i2c)
125 {
126 i2c->msg->buf[i2c->msgbuf_ptr++] = dc_i2c_read_byte(i2c);
127 dc_i2c_next_read(i2c);
128 }
129
130 static void dc_i2c_set_irq(struct dc_i2c *i2c, int enable)
131 {
132 if (enable)
133 writeb_relaxed(1, i2c->regs + II_INTFLAG_CLEAR);
134 writeb_relaxed(!!enable, i2c->regs + II_INTENABLE);
135 }
136
137 static int dc_i2c_cmd_status(struct dc_i2c *i2c)
138 {
139 u8 cmd = readb_relaxed(i2c->regs + II_COMMAND);
140
141 return II_COMMAND_COMPLETION_STATUS(cmd);
142 }
143
144 static void dc_i2c_start_msg(struct dc_i2c *i2c, int first)
145 {
146 struct i2c_msg *msg = i2c->msg;
147
148 if (!(msg->flags & I2C_M_NOSTART)) {
149 i2c->state = STATE_START;
150 dc_i2c_cmd(i2c, first ? II_CMD_START : II_CMD_RESTART);
151 } else if (msg->flags & I2C_M_RD) {
152 i2c->state = STATE_READ;
153 dc_i2c_next_read(i2c);
154 } else {
155 i2c->state = STATE_WRITE;
156 dc_i2c_write_buf(i2c);
157 }
158 }
159
160 static irqreturn_t dc_i2c_irq(int irq, void *dev_id)
161 {
162 struct dc_i2c *i2c = dev_id;
163 int cmd_status = dc_i2c_cmd_status(i2c);
164 unsigned long flags;
165 u8 addr_cmd;
166
167 writeb_relaxed(1, i2c->regs + II_INTFLAG_CLEAR);
168
169 spin_lock_irqsave(&i2c->lock, flags);
170
171 if (cmd_status == II_CMD_STATUS_ACK_BAD
172 || cmd_status == II_CMD_STATUS_ABORT) {
173 i2c->error = -EIO;
174 complete(&i2c->done);
175 goto out;
176 }
177
178 switch (i2c->state) {
179 case STATE_START:
180 addr_cmd = dc_i2c_addr_cmd(i2c->msg);
181 dc_i2c_write_byte(i2c, addr_cmd);
182 i2c->state = STATE_ADDR;
183 break;
184 case STATE_ADDR:
185 if (i2c->msg->flags & I2C_M_RD) {
186 dc_i2c_next_read(i2c);
187 i2c->state = STATE_READ;
188 break;
189 }
190 i2c->state = STATE_WRITE;
191 /* fall through */
192 case STATE_WRITE:
193 if (i2c->msgbuf_ptr < i2c->msg->len)
194 dc_i2c_write_buf(i2c);
195 else
196 dc_i2c_stop(i2c);
197 break;
198 case STATE_READ:
199 if (i2c->msgbuf_ptr < i2c->msg->len)
200 dc_i2c_read_buf(i2c);
201 else
202 dc_i2c_stop(i2c);
203 break;
204 case STATE_STOP:
205 i2c->state = STATE_IDLE;
206 complete(&i2c->done);
207 break;
208 }
209
210 out:
211 spin_unlock_irqrestore(&i2c->lock, flags);
212 return IRQ_HANDLED;
213 }
214
215 static int dc_i2c_xfer_msg(struct dc_i2c *i2c, struct i2c_msg *msg, int first,
216 int last)
217 {
218 unsigned long timeout = msecs_to_jiffies(TIMEOUT_MS);
219 unsigned long flags;
220
221 spin_lock_irqsave(&i2c->lock, flags);
222 i2c->msg = msg;
223 i2c->msgbuf_ptr = 0;
224 i2c->last = last;
225 i2c->error = 0;
226
227 reinit_completion(&i2c->done);
228 dc_i2c_set_irq(i2c, 1);
229 dc_i2c_start_msg(i2c, first);
230 spin_unlock_irqrestore(&i2c->lock, flags);
231
232 timeout = wait_for_completion_timeout(&i2c->done, timeout);
233 dc_i2c_set_irq(i2c, 0);
234 if (timeout == 0) {
235 i2c->state = STATE_IDLE;
236 return -ETIMEDOUT;
237 }
238
239 if (i2c->error)
240 return i2c->error;
241
242 return 0;
243 }
244
245 static int dc_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
246 {
247 struct dc_i2c *i2c = adap->algo_data;
248 int i, ret;
249
250 for (i = 0; i < num; i++) {
251 ret = dc_i2c_xfer_msg(i2c, &msgs[i], i == 0, i == num - 1);
252 if (ret)
253 return ret;
254 }
255
256 return num;
257 }
258
259 static int dc_i2c_init_hw(struct dc_i2c *i2c)
260 {
261 unsigned long clk_rate = clk_get_rate(i2c->clk);
262 unsigned int clocktime;
263
264 writeb_relaxed(II_CONTROL_LOCAL_RESET, i2c->regs + II_CONTROL);
265 udelay(100);
266 writeb_relaxed(0, i2c->regs + II_CONTROL);
267 udelay(100);
268
269 clocktime = DIV_ROUND_UP(clk_rate, 64 * i2c->frequency);
270 if (clocktime < 1 || clocktime > 0xff) {
271 dev_err(i2c->dev, "can't set bus speed of %u Hz\n",
272 i2c->frequency);
273 return -EINVAL;
274 }
275 writeb_relaxed(clocktime - 1, i2c->regs + II_CLOCKTIME);
276
277 return 0;
278 }
279
280 static u32 dc_i2c_func(struct i2c_adapter *adap)
281 {
282 return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL | I2C_FUNC_NOSTART;
283 }
284
285 static const struct i2c_algorithm dc_i2c_algorithm = {
286 .master_xfer = dc_i2c_xfer,
287 .functionality = dc_i2c_func,
288 };
289
290 static int dc_i2c_probe(struct platform_device *pdev)
291 {
292 struct device_node *np = pdev->dev.of_node;
293 struct dc_i2c *i2c;
294 struct resource *r;
295 int ret = 0, irq;
296
297 i2c = devm_kzalloc(&pdev->dev, sizeof(struct dc_i2c), GFP_KERNEL);
298 if (!i2c)
299 return -ENOMEM;
300
301 if (of_property_read_u32(pdev->dev.of_node, "clock-frequency",
302 &i2c->frequency))
303 i2c->frequency = DEFAULT_FREQ;
304
305 i2c->dev = &pdev->dev;
306 platform_set_drvdata(pdev, i2c);
307
308 spin_lock_init(&i2c->lock);
309 init_completion(&i2c->done);
310
311 i2c->clk = devm_clk_get(&pdev->dev, NULL);
312 if (IS_ERR(i2c->clk))
313 return PTR_ERR(i2c->clk);
314
315 r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
316 i2c->regs = devm_ioremap_resource(&pdev->dev, r);
317 if (IS_ERR(i2c->regs))
318 return PTR_ERR(i2c->regs);
319
320 irq = platform_get_irq(pdev, 0);
321 if (irq < 0)
322 return irq;
323
324 ret = devm_request_irq(&pdev->dev, irq, dc_i2c_irq, 0,
325 dev_name(&pdev->dev), i2c);
326 if (ret < 0)
327 return ret;
328
329 strlcpy(i2c->adap.name, "Conexant Digicolor I2C adapter",
330 sizeof(i2c->adap.name));
331 i2c->adap.owner = THIS_MODULE;
332 i2c->adap.algo = &dc_i2c_algorithm;
333 i2c->adap.dev.parent = &pdev->dev;
334 i2c->adap.dev.of_node = np;
335 i2c->adap.algo_data = i2c;
336
337 ret = dc_i2c_init_hw(i2c);
338 if (ret)
339 return ret;
340
341 ret = clk_prepare_enable(i2c->clk);
342 if (ret < 0)
343 return ret;
344
345 ret = i2c_add_adapter(&i2c->adap);
346 if (ret < 0) {
347 clk_disable_unprepare(i2c->clk);
348 return ret;
349 }
350
351 return 0;
352 }
353
354 static int dc_i2c_remove(struct platform_device *pdev)
355 {
356 struct dc_i2c *i2c = platform_get_drvdata(pdev);
357
358 i2c_del_adapter(&i2c->adap);
359 clk_disable_unprepare(i2c->clk);
360
361 return 0;
362 }
363
364 static const struct of_device_id dc_i2c_match[] = {
365 { .compatible = "cnxt,cx92755-i2c" },
366 { },
367 };
368 MODULE_DEVICE_TABLE(of, dc_i2c_match);
369
370 static struct platform_driver dc_i2c_driver = {
371 .probe = dc_i2c_probe,
372 .remove = dc_i2c_remove,
373 .driver = {
374 .name = "digicolor-i2c",
375 .of_match_table = dc_i2c_match,
376 },
377 };
378 module_platform_driver(dc_i2c_driver);
379
380 MODULE_AUTHOR("Baruch Siach <baruch@tkos.co.il>");
381 MODULE_DESCRIPTION("Conexant Digicolor I2C master driver");
382 MODULE_LICENSE("GPL v2");
Linux with added FPC-III support