drivers/i2c/busses/i2c-sh_mobile.c

   1 /*
   2  * SuperH Mobile I2C Controller
   3  *
   4  * Copyright (C) 2008 Magnus Damm
   5  *
   6  * Portions of the code based on out-of-tree driver i2c-sh7343.c
   7  * Copyright (c) 2006 Carlos Munoz <carlos@kenati.com>
   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
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 #include <linux/kernel.h>
  24 #include <linux/module.h>
  25 #include <linux/init.h>
  26 #include <linux/delay.h>
  27 #include <linux/platform_device.h>
  28 #include <linux/interrupt.h>
  29 #include <linux/i2c.h>
  30 #include <linux/err.h>
  31 #include <linux/clk.h>
  32 #include <linux/io.h>
  33
  34 enum sh_mobile_i2c_op {
  35         OP_START = 0,
  36         OP_TX_ONLY,
  37         OP_TX_STOP,
  38         OP_TX_TO_RX,
  39         OP_RX_ONLY,
  40         OP_RX_STOP,
  41 };
  42
  43 struct sh_mobile_i2c_data {
  44         struct device *dev;
  45         void __iomem *reg;
  46         struct i2c_adapter adap;
  47
  48         struct clk *clk;
  49         u_int8_t iccl;
  50         u_int8_t icch;
  51
  52         spinlock_t lock;
  53         wait_queue_head_t wait;
  54         struct i2c_msg *msg;
  55         int pos;
  56         int sr;
  57 };
  58
  59 #define NORMAL_SPEED            100000 /* FAST_SPEED 400000 */
  60
  61 /* Register offsets */
  62 #define ICDR(pd)                (pd->reg + 0x00)
  63 #define ICCR(pd)                (pd->reg + 0x04)
  64 #define ICSR(pd)                (pd->reg + 0x08)
  65 #define ICIC(pd)                (pd->reg + 0x0c)
  66 #define ICCL(pd)                (pd->reg + 0x10)
  67 #define ICCH(pd)                (pd->reg + 0x14)
  68
  69 /* Register bits */
  70 #define ICCR_ICE                0x80
  71 #define ICCR_RACK               0x40
  72 #define ICCR_TRS                0x10
  73 #define ICCR_BBSY               0x04
  74 #define ICCR_SCP                0x01
  75
  76 #define ICSR_SCLM               0x80
  77 #define ICSR_SDAM               0x40
  78 #define SW_DONE                 0x20
  79 #define ICSR_BUSY               0x10
  80 #define ICSR_AL                 0x08
  81 #define ICSR_TACK               0x04
  82 #define ICSR_WAIT               0x02
  83 #define ICSR_DTE                0x01
  84
  85 #define ICIC_ALE                0x08
  86 #define ICIC_TACKE              0x04
  87 #define ICIC_WAITE              0x02
  88 #define ICIC_DTEE               0x01
  89
  90 static void activate_ch(struct sh_mobile_i2c_data *pd)
  91 {
  92         /* Make sure the clock is enabled */
  93         clk_enable(pd->clk);
  94
  95         /* Enable channel and configure rx ack */
  96         iowrite8(ioread8(ICCR(pd)) | ICCR_ICE, ICCR(pd));
  97
  98         /* Mask all interrupts */
  99         iowrite8(0, ICIC(pd));
 100
 101         /* Set the clock */
 102         iowrite8(pd->iccl, ICCL(pd));
 103         iowrite8(pd->icch, ICCH(pd));
 104 }
 105
 106 static void deactivate_ch(struct sh_mobile_i2c_data *pd)
 107 {
 108         /* Clear/disable interrupts */
 109         iowrite8(0, ICSR(pd));
 110         iowrite8(0, ICIC(pd));
 111
 112         /* Disable channel */
 113         iowrite8(ioread8(ICCR(pd)) & ~ICCR_ICE, ICCR(pd));
 114
 115         /* Disable clock */
 116         clk_disable(pd->clk);
 117 }
 118
 119 static unsigned char i2c_op(struct sh_mobile_i2c_data *pd,
 120                             enum sh_mobile_i2c_op op, unsigned char data)
 121 {
 122         unsigned char ret = 0;
 123         unsigned long flags;
 124
 125         dev_dbg(pd->dev, "op %d, data in 0x%02x\n", op, data);
 126
 127         spin_lock_irqsave(&pd->lock, flags);
 128
 129         switch (op) {
 130         case OP_START:
 131                 iowrite8(0x94, ICCR(pd));
 132                 break;
 133         case OP_TX_ONLY:
 134                 iowrite8(data, ICDR(pd));
 135                 break;
 136         case OP_TX_STOP:
 137                 iowrite8(data, ICDR(pd));
 138                 iowrite8(0x90, ICCR(pd));
 139                 iowrite8(ICIC_ALE | ICIC_TACKE, ICIC(pd));
 140                 break;
 141         case OP_TX_TO_RX:
 142                 iowrite8(data, ICDR(pd));
 143                 iowrite8(0x81, ICCR(pd));
 144                 break;
 145         case OP_RX_ONLY:
 146                 ret = ioread8(ICDR(pd));
 147                 break;
 148         case OP_RX_STOP:
 149                 ret = ioread8(ICDR(pd));
 150                 iowrite8(0xc0, ICCR(pd));
 151                 break;
 152         }
 153
 154         spin_unlock_irqrestore(&pd->lock, flags);
 155
 156         dev_dbg(pd->dev, "op %d, data out 0x%02x\n", op, ret);
 157         return ret;
 158 }
 159
 160 static irqreturn_t sh_mobile_i2c_isr(int irq, void *dev_id)
 161 {
 162         struct platform_device *dev = dev_id;
 163         struct sh_mobile_i2c_data *pd = platform_get_drvdata(dev);
 164         struct i2c_msg *msg = pd->msg;
 165         unsigned char data, sr;
 166         int wakeup = 0;
 167
 168         sr = ioread8(ICSR(pd));
 169         pd->sr |= sr;
 170
 171         dev_dbg(pd->dev, "i2c_isr 0x%02x 0x%02x %s %d %d!\n", sr, pd->sr,
 172                (msg->flags & I2C_M_RD) ? "read" : "write",
 173                pd->pos, msg->len);
 174
 175         if (sr & (ICSR_AL | ICSR_TACK)) {
 176                 iowrite8(0, ICIC(pd)); /* disable interrupts */
 177                 wakeup = 1;
 178                 goto do_wakeup;
 179         }
 180
 181         if (pd->pos == msg->len) {
 182                 i2c_op(pd, OP_RX_ONLY, 0);
 183                 wakeup = 1;
 184                 goto do_wakeup;
 185         }
 186
 187         if (pd->pos == -1) {
 188                 data = (msg->addr & 0x7f) << 1;
 189                 data |= (msg->flags & I2C_M_RD) ? 1 : 0;
 190         } else
 191                 data = msg->buf[pd->pos];
 192
 193         if ((pd->pos == -1) || !(msg->flags & I2C_M_RD)) {
 194                 if (msg->flags & I2C_M_RD)
 195                         i2c_op(pd, OP_TX_TO_RX, data);
 196                 else if (pd->pos == (msg->len - 1)) {
 197                         i2c_op(pd, OP_TX_STOP, data);
 198                         wakeup = 1;
 199                 } else
 200                         i2c_op(pd, OP_TX_ONLY, data);
 201         } else {
 202                 if (pd->pos == (msg->len - 1))
 203                         data = i2c_op(pd, OP_RX_STOP, 0);
 204                 else
 205                         data = i2c_op(pd, OP_RX_ONLY, 0);
 206
 207                 msg->buf[pd->pos] = data;
 208         }
 209         pd->pos++;
 210
 211  do_wakeup:
 212         if (wakeup) {
 213                 pd->sr |= SW_DONE;
 214                 wake_up(&pd->wait);
 215         }
 216
 217         return IRQ_HANDLED;
 218 }
 219
 220 static int start_ch(struct sh_mobile_i2c_data *pd, struct i2c_msg *usr_msg)
 221 {
 222         /* Initialize channel registers */
 223         iowrite8(ioread8(ICCR(pd)) & ~ICCR_ICE, ICCR(pd));
 224
 225         /* Enable channel and configure rx ack */
 226         iowrite8(ioread8(ICCR(pd)) | ICCR_ICE, ICCR(pd));
 227
 228         /* Set the clock */
 229         iowrite8(pd->iccl, ICCL(pd));
 230         iowrite8(pd->icch, ICCH(pd));
 231
 232         pd->msg = usr_msg;
 233         pd->pos = -1;
 234         pd->sr = 0;
 235
 236         /* Enable all interrupts except wait */
 237         iowrite8(ioread8(ICIC(pd)) | ICIC_ALE | ICIC_TACKE | ICIC_DTEE,
 238                  ICIC(pd));
 239         return 0;
 240 }
 241
 242 static int sh_mobile_i2c_xfer(struct i2c_adapter *adapter,
 243                               struct i2c_msg *msgs,
 244                               int num)
 245 {
 246         struct sh_mobile_i2c_data *pd = i2c_get_adapdata(adapter);
 247         struct i2c_msg  *msg;
 248         int err = 0;
 249         u_int8_t val;
 250         int i, k, retry_count;
 251
 252         activate_ch(pd);
 253
 254         /* Process all messages */
 255         for (i = 0; i < num; i++) {
 256                 msg = &msgs[i];
 257
 258                 err = start_ch(pd, msg);
 259                 if (err)
 260                         break;
 261
 262                 i2c_op(pd, OP_START, 0);
 263
 264                 /* The interrupt handler takes care of the rest... */
 265                 k = wait_event_timeout(pd->wait,
 266                                        pd->sr & (ICSR_TACK | SW_DONE),
 267                                        5 * HZ);
 268                 if (!k)
 269                         dev_err(pd->dev, "Transfer request timed out\n");
 270
 271                 retry_count = 10;
 272 again:
 273                 val = ioread8(ICSR(pd));
 274
 275                 dev_dbg(pd->dev, "val 0x%02x pd->sr 0x%02x\n", val, pd->sr);
 276
 277                 if ((val | pd->sr) & (ICSR_TACK | ICSR_AL)) {
 278                         err = -EIO;
 279                         break;
 280                 }
 281
 282                 /* the interrupt handler may wake us up before the
 283                  * transfer is finished, so poll the hardware
 284                  * until we're done.
 285                  */
 286
 287                 if (!(!(val & ICSR_BUSY) && (val & ICSR_SCLM) &&
 288                       (val & ICSR_SDAM))) {
 289                         msleep(1);
 290                         if (retry_count--)
 291                                 goto again;
 292
 293                         err = -EIO;
 294                         dev_err(pd->dev, "Polling timed out\n");
 295                         break;
 296                 }
 297         }
 298
 299         deactivate_ch(pd);
 300
 301         if (!err)
 302                 err = num;
 303         return err;
 304 }
 305
 306 static u32 sh_mobile_i2c_func(struct i2c_adapter *adapter)
 307 {
 308         return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
 309 }
 310
 311 static struct i2c_algorithm sh_mobile_i2c_algorithm = {
 312         .functionality  = sh_mobile_i2c_func,
 313         .master_xfer    = sh_mobile_i2c_xfer,
 314 };
 315
 316 static void sh_mobile_i2c_setup_channel(struct platform_device *dev)
 317 {
 318         struct sh_mobile_i2c_data *pd = platform_get_drvdata(dev);
 319         unsigned long peripheral_clk = clk_get_rate(pd->clk);
 320         u_int32_t num;
 321         u_int32_t denom;
 322         u_int32_t tmp;
 323
 324         spin_lock_init(&pd->lock);
 325         init_waitqueue_head(&pd->wait);
 326
 327         /* Calculate the value for iccl. From the data sheet:
 328          * iccl = (p clock / transfer rate) * (L / (L + H))
 329          * where L and H are the SCL low/high ratio (5/4 in this case).
 330          * We also round off the result.
 331          */
 332         num = peripheral_clk * 5;
 333         denom = NORMAL_SPEED * 9;
 334         tmp = num * 10 / denom;
 335         if (tmp % 10 >= 5)
 336                 pd->iccl = (u_int8_t)((num/denom) + 1);
 337         else
 338                 pd->iccl = (u_int8_t)(num/denom);
 339
 340         /* Calculate the value for icch. From the data sheet:
 341            icch = (p clock / transfer rate) * (H / (L + H)) */
 342         num = peripheral_clk * 4;
 343         tmp = num * 10 / denom;
 344         if (tmp % 10 >= 5)
 345                 pd->icch = (u_int8_t)((num/denom) + 1);
 346         else
 347                 pd->icch = (u_int8_t)(num/denom);
 348 }
 349
 350 static int sh_mobile_i2c_hook_irqs(struct platform_device *dev, int hook)
 351 {
 352         struct resource *res;
 353         int ret = -ENXIO;
 354         int q, m;
 355         int k = 0;
 356         int n = 0;
 357
 358         while ((res = platform_get_resource(dev, IORESOURCE_IRQ, k))) {
 359                 for (n = res->start; hook && n <= res->end; n++) {
 360                         if (request_irq(n, sh_mobile_i2c_isr, IRQF_DISABLED,
 361                                         dev->dev.bus_id, dev))
 362                                 goto rollback;
 363                 }
 364                 k++;
 365         }
 366
 367         if (hook)
 368                 return k > 0 ? 0 : -ENOENT;
 369
 370         k--;
 371         ret = 0;
 372
 373  rollback:
 374         for (q = k; k >= 0; k--) {
 375                 for (m = n; m >= res->start; m--)
 376                         free_irq(m, dev);
 377
 378                 res = platform_get_resource(dev, IORESOURCE_IRQ, k - 1);
 379                 m = res->end;
 380         }
 381
 382         return ret;
 383 }
 384
 385 static int sh_mobile_i2c_probe(struct platform_device *dev)
 386 {
 387         struct sh_mobile_i2c_data *pd;
 388         struct i2c_adapter *adap;
 389         struct resource *res;
 390         int size;
 391         int ret;
 392
 393         pd = kzalloc(sizeof(struct sh_mobile_i2c_data), GFP_KERNEL);
 394         if (pd == NULL) {
 395                 dev_err(&dev->dev, "cannot allocate private data\n");
 396                 return -ENOMEM;
 397         }
 398
 399         pd->clk = clk_get(&dev->dev, "peripheral_clk");
 400         if (IS_ERR(pd->clk)) {
 401                 dev_err(&dev->dev, "cannot get peripheral clock\n");
 402                 ret = PTR_ERR(pd->clk);
 403                 goto err;
 404         }
 405
 406         ret = sh_mobile_i2c_hook_irqs(dev, 1);
 407         if (ret) {
 408                 dev_err(&dev->dev, "cannot request IRQ\n");
 409                 goto err_clk;
 410         }
 411
 412         pd->dev = &dev->dev;
 413         platform_set_drvdata(dev, pd);
 414
 415         res = platform_get_resource(dev, IORESOURCE_MEM, 0);
 416         if (res == NULL) {
 417                 dev_err(&dev->dev, "cannot find IO resource\n");
 418                 ret = -ENOENT;
 419                 goto err_irq;
 420         }
 421
 422         size = (res->end - res->start) + 1;
 423
 424         pd->reg = ioremap(res->start, size);
 425         if (pd->reg == NULL) {
 426                 dev_err(&dev->dev, "cannot map IO\n");
 427                 ret = -ENXIO;
 428                 goto err_irq;
 429         }
 430
 431         /* setup the private data */
 432         adap = &pd->adap;
 433         i2c_set_adapdata(adap, pd);
 434
 435         adap->owner = THIS_MODULE;
 436         adap->algo = &sh_mobile_i2c_algorithm;
 437         adap->dev.parent = &dev->dev;
 438         adap->retries = 5;
 439         adap->nr = dev->id;
 440
 441         strlcpy(adap->name, dev->name, sizeof(adap->name));
 442
 443         sh_mobile_i2c_setup_channel(dev);
 444
 445         ret = i2c_add_numbered_adapter(adap);
 446         if (ret < 0) {
 447                 dev_err(&dev->dev, "cannot add numbered adapter\n");
 448                 goto err_all;
 449         }
 450
 451         return 0;
 452
 453  err_all:
 454         iounmap(pd->reg);
 455  err_irq:
 456         sh_mobile_i2c_hook_irqs(dev, 0);
 457  err_clk:
 458         clk_put(pd->clk);
 459  err:
 460         kfree(pd);
 461         return ret;
 462 }
 463
 464 static int sh_mobile_i2c_remove(struct platform_device *dev)
 465 {
 466         struct sh_mobile_i2c_data *pd = platform_get_drvdata(dev);
 467
 468         i2c_del_adapter(&pd->adap);
 469         iounmap(pd->reg);
 470         sh_mobile_i2c_hook_irqs(dev, 0);
 471         clk_put(pd->clk);
 472         kfree(pd);
 473         return 0;
 474 }
 475
 476 static struct platform_driver sh_mobile_i2c_driver = {
 477         .driver         = {
 478                 .name           = "i2c-sh_mobile",
 479                 .owner          = THIS_MODULE,
 480         },
 481         .probe          = sh_mobile_i2c_probe,
 482         .remove         = sh_mobile_i2c_remove,
 483 };
 484
 485 static int __init sh_mobile_i2c_adap_init(void)
 486 {
 487         return platform_driver_register(&sh_mobile_i2c_driver);
 488 }
 489
 490 static void __exit sh_mobile_i2c_adap_exit(void)
 491 {
 492         platform_driver_unregister(&sh_mobile_i2c_driver);
 493 }
 494
 495 module_init(sh_mobile_i2c_adap_init);
 496 module_exit(sh_mobile_i2c_adap_exit);
 497
 498 MODULE_DESCRIPTION("SuperH Mobile I2C Bus Controller driver");
 499 MODULE_AUTHOR("Magnus Damm");
 500 MODULE_LICENSE("GPL v2");