Merge tag 'v5.15.57' into rpi-5.15.y
[platform/kernel/linux-rpi.git] / drivers / i2c / busses / i2c-bcm2708.c
1 /*
2  * Driver for Broadcom BCM2708 BSC Controllers
3  *
4  * Copyright (C) 2012 Chris Boot & Frank Buss
5  *
6  * This driver is inspired by:
7  * i2c-ocores.c, by Peter Korsgaard <jacmet@sunsite.dk>
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22  */
23
24 #include <linux/kernel.h>
25 #include <linux/module.h>
26 #include <linux/spinlock.h>
27 #include <linux/clk.h>
28 #include <linux/err.h>
29 #include <linux/of.h>
30 #include <linux/platform_device.h>
31 #include <linux/io.h>
32 #include <linux/slab.h>
33 #include <linux/i2c.h>
34 #include <linux/interrupt.h>
35 #include <linux/sched.h>
36 #include <linux/wait.h>
37
38 /* BSC register offsets */
39 #define BSC_C                   0x00
40 #define BSC_S                   0x04
41 #define BSC_DLEN                0x08
42 #define BSC_A                   0x0c
43 #define BSC_FIFO                0x10
44 #define BSC_DIV                 0x14
45 #define BSC_DEL                 0x18
46 #define BSC_CLKT                0x1c
47
48 /* Bitfields in BSC_C */
49 #define BSC_C_I2CEN             0x00008000
50 #define BSC_C_INTR              0x00000400
51 #define BSC_C_INTT              0x00000200
52 #define BSC_C_INTD              0x00000100
53 #define BSC_C_ST                0x00000080
54 #define BSC_C_CLEAR_1           0x00000020
55 #define BSC_C_CLEAR_2           0x00000010
56 #define BSC_C_READ              0x00000001
57
58 /* Bitfields in BSC_S */
59 #define BSC_S_CLKT              0x00000200
60 #define BSC_S_ERR               0x00000100
61 #define BSC_S_RXF               0x00000080
62 #define BSC_S_TXE               0x00000040
63 #define BSC_S_RXD               0x00000020
64 #define BSC_S_TXD               0x00000010
65 #define BSC_S_RXR               0x00000008
66 #define BSC_S_TXW               0x00000004
67 #define BSC_S_DONE              0x00000002
68 #define BSC_S_TA                0x00000001
69
70 #define I2C_WAIT_LOOP_COUNT     200
71
72 #define DRV_NAME                "bcm2708_i2c"
73
74 static unsigned int baudrate;
75 module_param(baudrate, uint, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
76 MODULE_PARM_DESC(baudrate, "The I2C baudrate");
77
78 static bool combined = false;
79 module_param(combined, bool, 0644);
80 MODULE_PARM_DESC(combined, "Use combined transactions");
81
82 struct bcm2708_i2c {
83         struct i2c_adapter adapter;
84
85         spinlock_t lock;
86         void __iomem *base;
87         int irq;
88         struct clk *clk;
89         u32 cdiv;
90         u32 clk_tout;
91
92         struct completion done;
93
94         struct i2c_msg *msg;
95         int pos;
96         int nmsgs;
97         bool error;
98 };
99
100 static inline u32 bcm2708_rd(struct bcm2708_i2c *bi, unsigned reg)
101 {
102         return readl(bi->base + reg);
103 }
104
105 static inline void bcm2708_wr(struct bcm2708_i2c *bi, unsigned reg, u32 val)
106 {
107         writel(val, bi->base + reg);
108 }
109
110 static inline void bcm2708_bsc_reset(struct bcm2708_i2c *bi)
111 {
112         bcm2708_wr(bi, BSC_C, 0);
113         bcm2708_wr(bi, BSC_S, BSC_S_CLKT | BSC_S_ERR | BSC_S_DONE);
114 }
115
116 static inline void bcm2708_bsc_fifo_drain(struct bcm2708_i2c *bi)
117 {
118         while ((bi->pos < bi->msg->len) && (bcm2708_rd(bi, BSC_S) & BSC_S_RXD))
119                 bi->msg->buf[bi->pos++] = bcm2708_rd(bi, BSC_FIFO);
120 }
121
122 static inline void bcm2708_bsc_fifo_fill(struct bcm2708_i2c *bi)
123 {
124         while ((bi->pos < bi->msg->len) && (bcm2708_rd(bi, BSC_S) & BSC_S_TXD))
125                 bcm2708_wr(bi, BSC_FIFO, bi->msg->buf[bi->pos++]);
126 }
127
128 static inline int bcm2708_bsc_setup(struct bcm2708_i2c *bi)
129 {
130         u32 cdiv, s, clk_tout;
131         u32 c = BSC_C_I2CEN | BSC_C_INTD | BSC_C_ST | BSC_C_CLEAR_1;
132         int wait_loops = I2C_WAIT_LOOP_COUNT;
133
134         /* Can't call clk_get_rate as it locks a mutex and here we are spinlocked.
135          * Use the value that we cached in the probe.
136          */
137         cdiv = bi->cdiv;
138         clk_tout = bi->clk_tout;
139
140         if (bi->msg->flags & I2C_M_RD)
141                 c |= BSC_C_INTR | BSC_C_READ;
142         else
143                 c |= BSC_C_INTT;
144
145         bcm2708_wr(bi, BSC_CLKT, clk_tout);
146         bcm2708_wr(bi, BSC_DIV, cdiv);
147         bcm2708_wr(bi, BSC_A, bi->msg->addr);
148         bcm2708_wr(bi, BSC_DLEN, bi->msg->len);
149         if (combined)
150         {
151                 /* Do the next two messages meet combined transaction criteria?
152                    - Current message is a write, next message is a read
153                    - Both messages to same slave address
154                    - Write message can fit inside FIFO (16 bytes or less) */
155                 if ( (bi->nmsgs > 1) &&
156                         !(bi->msg[0].flags & I2C_M_RD) && (bi->msg[1].flags & I2C_M_RD) &&
157                          (bi->msg[0].addr == bi->msg[1].addr) && (bi->msg[0].len <= 16)) {
158
159                         /* Clear FIFO */
160                         bcm2708_wr(bi, BSC_C, BSC_C_CLEAR_1);
161
162                         /* Fill FIFO with entire write message (16 byte FIFO) */
163                         while (bi->pos < bi->msg->len) {
164                                 bcm2708_wr(bi, BSC_FIFO, bi->msg->buf[bi->pos++]);
165                         }
166                         /* Start write transfer (no interrupts, don't clear FIFO) */
167                         bcm2708_wr(bi, BSC_C, BSC_C_I2CEN | BSC_C_ST);
168
169                         /* poll for transfer start bit (should only take 1-20 polls) */
170                         do {
171                                 s = bcm2708_rd(bi, BSC_S);
172                         } while (!(s & (BSC_S_TA | BSC_S_ERR | BSC_S_CLKT | BSC_S_DONE)) && --wait_loops >= 0);
173
174                         /* did we time out or some error occured? */
175                         if (wait_loops < 0 || (s & (BSC_S_ERR | BSC_S_CLKT))) {
176                                 return -1;
177                         }
178
179                         /* Send next read message before the write transfer finishes. */
180                         bi->nmsgs--;
181                         bi->msg++;
182                         bi->pos = 0;
183                         bcm2708_wr(bi, BSC_DLEN, bi->msg->len);
184                         c = BSC_C_I2CEN | BSC_C_INTD | BSC_C_INTR | BSC_C_ST | BSC_C_READ;
185                 }
186         }
187         bcm2708_wr(bi, BSC_C, c);
188
189         return 0;
190 }
191
192 static irqreturn_t bcm2708_i2c_interrupt(int irq, void *dev_id)
193 {
194         struct bcm2708_i2c *bi = dev_id;
195         bool handled = true;
196         u32 s;
197         int ret;
198
199         spin_lock(&bi->lock);
200
201         /* we may see camera interrupts on the "other" I2C channel
202                    Just return if we've not sent anything */
203         if (!bi->nmsgs || !bi->msg) {
204                 goto early_exit;
205         }
206
207         s = bcm2708_rd(bi, BSC_S);
208
209         if (s & (BSC_S_CLKT | BSC_S_ERR)) {
210                 bcm2708_bsc_reset(bi);
211                 bi->error = true;
212
213                 bi->msg = 0; /* to inform the that all work is done */
214                 bi->nmsgs = 0;
215                 /* wake up our bh */
216                 complete(&bi->done);
217         } else if (s & BSC_S_DONE) {
218                 bi->nmsgs--;
219
220                 if (bi->msg->flags & I2C_M_RD) {
221                         bcm2708_bsc_fifo_drain(bi);
222                 }
223
224                 bcm2708_bsc_reset(bi);
225
226                 if (bi->nmsgs) {
227                         /* advance to next message */
228                         bi->msg++;
229                         bi->pos = 0;
230                         ret = bcm2708_bsc_setup(bi);
231                         if (ret < 0) {
232                                 bcm2708_bsc_reset(bi);
233                                 bi->error = true;
234                                 bi->msg = 0; /* to inform the that all work is done */
235                                 bi->nmsgs = 0;
236                                 /* wake up our bh */
237                                 complete(&bi->done);
238                                 goto early_exit;
239                         }
240                 } else {
241                         bi->msg = 0; /* to inform the that all work is done */
242                         bi->nmsgs = 0;
243                         /* wake up our bh */
244                         complete(&bi->done);
245                 }
246         } else if (s & BSC_S_TXW) {
247                 bcm2708_bsc_fifo_fill(bi);
248         } else if (s & BSC_S_RXR) {
249                 bcm2708_bsc_fifo_drain(bi);
250         } else {
251                 handled = false;
252         }
253
254 early_exit:
255         spin_unlock(&bi->lock);
256
257         return handled ? IRQ_HANDLED : IRQ_NONE;
258 }
259
260 static int bcm2708_i2c_master_xfer(struct i2c_adapter *adap,
261         struct i2c_msg *msgs, int num)
262 {
263         struct bcm2708_i2c *bi = adap->algo_data;
264         unsigned long flags;
265         int ret;
266
267         spin_lock_irqsave(&bi->lock, flags);
268
269         reinit_completion(&bi->done);
270         bi->msg = msgs;
271         bi->pos = 0;
272         bi->nmsgs = num;
273         bi->error = false;
274
275         ret = bcm2708_bsc_setup(bi);
276
277         spin_unlock_irqrestore(&bi->lock, flags);
278
279         /* check the result of the setup */
280         if (ret < 0)
281         {
282                 dev_err(&adap->dev, "transfer setup timed out\n");
283                 goto error_timeout;
284         }
285
286         ret = wait_for_completion_timeout(&bi->done, adap->timeout);
287         if (ret == 0) {
288                 dev_err(&adap->dev, "transfer timed out\n");
289                 goto error_timeout;
290         }
291
292         ret = bi->error ? -EIO : num;
293         return ret;
294
295 error_timeout:
296         spin_lock_irqsave(&bi->lock, flags);
297         bcm2708_bsc_reset(bi);
298         bi->msg = 0; /* to inform the interrupt handler that there's nothing else to be done */
299         bi->nmsgs = 0;
300         spin_unlock_irqrestore(&bi->lock, flags);
301         return -ETIMEDOUT;
302 }
303
304 static u32 bcm2708_i2c_functionality(struct i2c_adapter *adap)
305 {
306         return I2C_FUNC_I2C | /*I2C_FUNC_10BIT_ADDR |*/ I2C_FUNC_SMBUS_EMUL;
307 }
308
309 static struct i2c_algorithm bcm2708_i2c_algorithm = {
310         .master_xfer = bcm2708_i2c_master_xfer,
311         .functionality = bcm2708_i2c_functionality,
312 };
313
314 static int bcm2708_i2c_probe(struct platform_device *pdev)
315 {
316         struct resource *regs;
317         int irq, err = -ENOMEM;
318         struct clk *clk;
319         struct bcm2708_i2c *bi;
320         struct i2c_adapter *adap;
321         unsigned long bus_hz;
322         u32 cdiv, clk_tout;
323         u32 baud;
324
325         baud = CONFIG_I2C_BCM2708_BAUDRATE;
326
327         if (pdev->dev.of_node) {
328                 u32 bus_clk_rate;
329                 pdev->id = of_alias_get_id(pdev->dev.of_node, "i2c");
330                 if (pdev->id < 0) {
331                         dev_err(&pdev->dev, "alias is missing\n");
332                         return -EINVAL;
333                 }
334                 if (!of_property_read_u32(pdev->dev.of_node,
335                                         "clock-frequency", &bus_clk_rate))
336                         baud = bus_clk_rate;
337                 else
338                         dev_warn(&pdev->dev,
339                                 "Could not read clock-frequency property\n");
340         }
341
342         if (baudrate)
343                 baud = baudrate;
344
345         regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
346         if (!regs) {
347                 dev_err(&pdev->dev, "could not get IO memory\n");
348                 return -ENXIO;
349         }
350
351         irq = platform_get_irq(pdev, 0);
352         if (irq < 0) {
353                 dev_err(&pdev->dev, "could not get IRQ\n");
354                 return irq;
355         }
356
357         clk = clk_get(&pdev->dev, NULL);
358         if (IS_ERR(clk)) {
359                 dev_err(&pdev->dev, "could not find clk: %ld\n", PTR_ERR(clk));
360                 return PTR_ERR(clk);
361         }
362
363         err = clk_prepare_enable(clk);
364         if (err) {
365                 dev_err(&pdev->dev, "could not enable clk: %d\n", err);
366                 goto out_clk_put;
367         }
368
369         bi = kzalloc(sizeof(*bi), GFP_KERNEL);
370         if (!bi)
371                 goto out_clk_disable;
372
373         platform_set_drvdata(pdev, bi);
374
375         adap = &bi->adapter;
376         adap->class = I2C_CLASS_HWMON | I2C_CLASS_DDC;
377         adap->algo = &bcm2708_i2c_algorithm;
378         adap->algo_data = bi;
379         adap->dev.parent = &pdev->dev;
380         adap->nr = pdev->id;
381         strlcpy(adap->name, dev_name(&pdev->dev), sizeof(adap->name));
382         adap->dev.of_node = pdev->dev.of_node;
383
384         switch (pdev->id) {
385         case 0:
386                 adap->class = I2C_CLASS_HWMON;
387                 break;
388         case 1:
389                 adap->class = I2C_CLASS_DDC;
390                 break;
391         case 2:
392                 adap->class = I2C_CLASS_DDC;
393                 break;
394         default:
395                 dev_err(&pdev->dev, "can only bind to BSC 0, 1 or 2\n");
396                 err = -ENXIO;
397                 goto out_free_bi;
398         }
399
400         spin_lock_init(&bi->lock);
401         init_completion(&bi->done);
402
403         bi->base = ioremap(regs->start, resource_size(regs));
404         if (!bi->base) {
405                 dev_err(&pdev->dev, "could not remap memory\n");
406                 goto out_free_bi;
407         }
408
409         bi->irq = irq;
410         bi->clk = clk;
411
412         err = request_irq(irq, bcm2708_i2c_interrupt, IRQF_SHARED,
413                         dev_name(&pdev->dev), bi);
414         if (err) {
415                 dev_err(&pdev->dev, "could not request IRQ: %d\n", err);
416                 goto out_iounmap;
417         }
418
419         bcm2708_bsc_reset(bi);
420
421         err = i2c_add_numbered_adapter(adap);
422         if (err < 0) {
423                 dev_err(&pdev->dev, "could not add I2C adapter: %d\n", err);
424                 goto out_free_irq;
425         }
426
427         bus_hz = clk_get_rate(bi->clk);
428         cdiv = bus_hz / baud;
429         if (cdiv > 0xffff) {
430                 cdiv = 0xffff;
431                 baud = bus_hz / cdiv;
432         }
433
434         clk_tout = 35/1000*baud; //35ms timeout as per SMBus specs.
435         if (clk_tout > 0xffff)
436                 clk_tout = 0xffff;
437         
438         bi->cdiv = cdiv;
439         bi->clk_tout = clk_tout;
440
441         dev_info(&pdev->dev, "BSC%d Controller at 0x%08lx (irq %d) (baudrate %d)\n",
442                 pdev->id, (unsigned long)regs->start, irq, baud);
443
444         return 0;
445
446 out_free_irq:
447         free_irq(bi->irq, bi);
448 out_iounmap:
449         iounmap(bi->base);
450 out_free_bi:
451         kfree(bi);
452 out_clk_disable:
453         clk_disable_unprepare(clk);
454 out_clk_put:
455         clk_put(clk);
456         return err;
457 }
458
459 static int bcm2708_i2c_remove(struct platform_device *pdev)
460 {
461         struct bcm2708_i2c *bi = platform_get_drvdata(pdev);
462
463         platform_set_drvdata(pdev, NULL);
464
465         i2c_del_adapter(&bi->adapter);
466         free_irq(bi->irq, bi);
467         iounmap(bi->base);
468         clk_disable_unprepare(bi->clk);
469         clk_put(bi->clk);
470         kfree(bi);
471
472         return 0;
473 }
474
475 static const struct of_device_id bcm2708_i2c_of_match[] = {
476         { .compatible = "brcm,bcm2708-i2c" },
477         {},
478 };
479 MODULE_DEVICE_TABLE(of, bcm2708_i2c_of_match);
480
481 static struct platform_driver bcm2708_i2c_driver = {
482         .driver         = {
483                 .name   = DRV_NAME,
484                 .owner  = THIS_MODULE,
485                 .of_match_table = bcm2708_i2c_of_match,
486         },
487         .probe          = bcm2708_i2c_probe,
488         .remove         = bcm2708_i2c_remove,
489 };
490
491 // module_platform_driver(bcm2708_i2c_driver);
492
493
494 static int __init bcm2708_i2c_init(void)
495 {
496         return platform_driver_register(&bcm2708_i2c_driver);
497 }
498
499 static void __exit bcm2708_i2c_exit(void)
500 {
501         platform_driver_unregister(&bcm2708_i2c_driver);
502 }
503
504 module_init(bcm2708_i2c_init);
505 module_exit(bcm2708_i2c_exit);
506
507
508
509 MODULE_DESCRIPTION("BSC controller driver for Broadcom BCM2708");
510 MODULE_AUTHOR("Chris Boot <bootc@bootc.net>");
511 MODULE_LICENSE("GPL v2");
512 MODULE_ALIAS("platform:" DRV_NAME);