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);