drivers/i2c/busses/i2c-at91.c

   1 /*
   2     i2c Support for Atmel's AT91 Two-Wire Interface (TWI)
   3
   4     Copyright (C) 2004 Rick Bronson
   5     Converted to 2.6 by Andrew Victor <andrew@sanpeople.com>
   6
   7     Borrowed heavily from original work by:
   8     Copyright (C) 2000 Philip Edelbrock <phil@stimpy.netroedge.com>
   9
  10     This program is free software; you can redistribute it and/or modify
  11     it under the terms of the GNU General Public License as published by
  12     the Free Software Foundation; either version 2 of the License, or
  13     (at your option) any later version.
  14 */
  15
  16 #include <linux/module.h>
  17 #include <linux/version.h>
  18 #include <linux/kernel.h>
  19 #include <linux/slab.h>
  20 #include <linux/types.h>
  21 #include <linux/delay.h>
  22 #include <linux/i2c.h>
  23 #include <linux/init.h>
  24 #include <linux/clk.h>
  25 #include <linux/platform_device.h>
  26
  27 #include <asm/io.h>
  28
  29 #include <asm/arch/at91_twi.h>
  30 #include <asm/arch/board.h>
  31 #include <asm/arch/cpu.h>
  32
  33 #define TWI_CLOCK               100000          /* Hz. max 400 Kbits/sec */
  34
  35
  36 static struct clk *twi_clk;
  37 static void __iomem *twi_base;
  38
  39 #define at91_twi_read(reg)              __raw_readl(twi_base + (reg))
  40 #define at91_twi_write(reg, val)        __raw_writel((val), twi_base + (reg))
  41
  42
  43 /*
  44  * Initialize the TWI hardware registers.
  45  */
  46 static void __devinit at91_twi_hwinit(void)
  47 {
  48         unsigned long cdiv, ckdiv;
  49
  50         at91_twi_write(AT91_TWI_IDR, 0xffffffff);       /* Disable all interrupts */
  51         at91_twi_write(AT91_TWI_CR, AT91_TWI_SWRST);    /* Reset peripheral */
  52         at91_twi_write(AT91_TWI_CR, AT91_TWI_MSEN);     /* Set Master mode */
  53
  54         /* Calcuate clock dividers */
  55         cdiv = (clk_get_rate(twi_clk) / (2 * TWI_CLOCK)) - 3;
  56         cdiv = cdiv + 1;        /* round up */
  57         ckdiv = 0;
  58         while (cdiv > 255) {
  59                 ckdiv++;
  60                 cdiv = cdiv >> 1;
  61         }
  62
  63         if (cpu_is_at91rm9200()) {                      /* AT91RM9200 Errata #22 */
  64                 if (ckdiv > 5) {
  65                         printk(KERN_ERR "AT91 I2C: Invalid TWI_CLOCK value!\n");
  66                         ckdiv = 5;
  67                 }
  68         }
  69
  70         at91_twi_write(AT91_TWI_CWGR, (ckdiv << 16) | (cdiv << 8) | cdiv);
  71 }
  72
  73 /*
  74  * Poll the i2c status register until the specified bit is set.
  75  * Returns 0 if timed out (100 msec).
  76  */
  77 static short at91_poll_status(unsigned long bit)
  78 {
  79         int loop_cntr = 10000;
  80
  81         do {
  82                 udelay(10);
  83         } while (!(at91_twi_read(AT91_TWI_SR) & bit) && (--loop_cntr > 0));
  84
  85         return (loop_cntr > 0);
  86 }
  87
  88 static int xfer_read(struct i2c_adapter *adap, unsigned char *buf, int length)
  89 {
  90         /* Send Start */
  91         at91_twi_write(AT91_TWI_CR, AT91_TWI_START);
  92
  93         /* Read data */
  94         while (length--) {
  95                 if (!length)    /* need to send Stop before reading last byte */
  96                         at91_twi_write(AT91_TWI_CR, AT91_TWI_STOP);
  97                 if (!at91_poll_status(AT91_TWI_RXRDY)) {
  98                         dev_dbg(&adap->dev, "RXRDY timeout\n");
  99                         return -ETIMEDOUT;
 100                 }
 101                 *buf++ = (at91_twi_read(AT91_TWI_RHR) & 0xff);
 102         }
 103
 104         return 0;
 105 }
 106
 107 static int xfer_write(struct i2c_adapter *adap, unsigned char *buf, int length)
 108 {
 109         /* Load first byte into transmitter */
 110         at91_twi_write(AT91_TWI_THR, *buf++);
 111
 112         /* Send Start */
 113         at91_twi_write(AT91_TWI_CR, AT91_TWI_START);
 114
 115         do {
 116                 if (!at91_poll_status(AT91_TWI_TXRDY)) {
 117                         dev_dbg(&adap->dev, "TXRDY timeout\n");
 118                         return -ETIMEDOUT;
 119                 }
 120
 121                 length--;       /* byte was transmitted */
 122
 123                 if (length > 0)         /* more data to send? */
 124                         at91_twi_write(AT91_TWI_THR, *buf++);
 125         } while (length);
 126
 127         /* Send Stop */
 128         at91_twi_write(AT91_TWI_CR, AT91_TWI_STOP);
 129
 130         return 0;
 131 }
 132
 133 /*
 134  * Generic i2c master transfer entrypoint.
 135  *
 136  * Note: We do not use Atmel's feature of storing the "internal device address".
 137  * Instead the "internal device address" has to be written using a seperate
 138  * i2c message.
 139  * http://lists.arm.linux.org.uk/pipermail/linux-arm-kernel/2004-September/024411.html
 140  */
 141 static int at91_xfer(struct i2c_adapter *adap, struct i2c_msg *pmsg, int num)
 142 {
 143         int i, ret;
 144
 145         dev_dbg(&adap->dev, "at91_xfer: processing %d messages:\n", num);
 146
 147         for (i = 0; i < num; i++) {
 148                 dev_dbg(&adap->dev, " #%d: %sing %d byte%s %s 0x%02x\n", i,
 149                         pmsg->flags & I2C_M_RD ? "read" : "writ",
 150                         pmsg->len, pmsg->len > 1 ? "s" : "",
 151                         pmsg->flags & I2C_M_RD ? "from" : "to", pmsg->addr);
 152
 153                 at91_twi_write(AT91_TWI_MMR, (pmsg->addr << 16)
 154                         | ((pmsg->flags & I2C_M_RD) ? AT91_TWI_MREAD : 0));
 155
 156                 if (pmsg->len && pmsg->buf) {   /* sanity check */
 157                         if (pmsg->flags & I2C_M_RD)
 158                                 ret = xfer_read(adap, pmsg->buf, pmsg->len);
 159                         else
 160                                 ret = xfer_write(adap, pmsg->buf, pmsg->len);
 161
 162                         if (ret)
 163                                 return ret;
 164
 165                         /* Wait until transfer is finished */
 166                         if (!at91_poll_status(AT91_TWI_TXCOMP)) {
 167                                 dev_dbg(&adap->dev, "TXCOMP timeout\n");
 168                                 return -ETIMEDOUT;
 169                         }
 170                 }
 171                 dev_dbg(&adap->dev, "transfer complete\n");
 172                 pmsg++;         /* next message */
 173         }
 174         return i;
 175 }
 176
 177 /*
 178  * Return list of supported functionality.
 179  */
 180 static u32 at91_func(struct i2c_adapter *adapter)
 181 {
 182         return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
 183 }
 184
 185 static struct i2c_algorithm at91_algorithm = {
 186         .master_xfer    = at91_xfer,
 187         .functionality  = at91_func,
 188 };
 189
 190 /*
 191  * Main initialization routine.
 192  */
 193 static int __devinit at91_i2c_probe(struct platform_device *pdev)
 194 {
 195         struct i2c_adapter *adapter;
 196         struct resource *res;
 197         int rc;
 198
 199         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 200         if (!res)
 201                 return -ENXIO;
 202
 203         if (!request_mem_region(res->start, res->end - res->start + 1, "at91_i2c"))
 204                 return -EBUSY;
 205
 206         twi_base = ioremap(res->start, res->end - res->start + 1);
 207         if (!twi_base) {
 208                 rc = -ENOMEM;
 209                 goto fail0;
 210         }
 211
 212         twi_clk = clk_get(NULL, "twi_clk");
 213         if (IS_ERR(twi_clk)) {
 214                 dev_err(&pdev->dev, "no clock defined\n");
 215                 rc = -ENODEV;
 216                 goto fail1;
 217         }
 218
 219         adapter = kzalloc(sizeof(struct i2c_adapter), GFP_KERNEL);
 220         if (adapter == NULL) {
 221                 dev_err(&pdev->dev, "can't allocate inteface!\n");
 222                 rc = -ENOMEM;
 223                 goto fail2;
 224         }
 225         sprintf(adapter->name, "AT91");
 226         adapter->algo = &at91_algorithm;
 227         adapter->class = I2C_CLASS_HWMON;
 228         adapter->dev.parent = &pdev->dev;
 229
 230         platform_set_drvdata(pdev, adapter);
 231
 232         clk_enable(twi_clk);            /* enable peripheral clock */
 233         at91_twi_hwinit();              /* initialize TWI controller */
 234
 235         rc = i2c_add_adapter(adapter);
 236         if (rc) {
 237                 dev_err(&pdev->dev, "Adapter %s registration failed\n",
 238                                 adapter->name);
 239                 goto fail3;
 240         }
 241
 242         dev_info(&pdev->dev, "AT91 i2c bus driver.\n");
 243         return 0;
 244
 245 fail3:
 246         platform_set_drvdata(pdev, NULL);
 247         kfree(adapter);
 248         clk_disable(twi_clk);
 249 fail2:
 250         clk_put(twi_clk);
 251 fail1:
 252         iounmap(twi_base);
 253 fail0:
 254         release_mem_region(res->start, res->end - res->start + 1);
 255
 256         return rc;
 257 }
 258
 259 static int __devexit at91_i2c_remove(struct platform_device *pdev)
 260 {
 261         struct i2c_adapter *adapter = platform_get_drvdata(pdev);
 262         struct resource *res;
 263         int rc;
 264
 265         rc = i2c_del_adapter(adapter);
 266         platform_set_drvdata(pdev, NULL);
 267
 268         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 269         iounmap(twi_base);
 270         release_mem_region(res->start, res->end - res->start + 1);
 271
 272         clk_disable(twi_clk);           /* disable peripheral clock */
 273         clk_put(twi_clk);
 274
 275         return rc;
 276 }
 277
 278 #ifdef CONFIG_PM
 279
 280 /* NOTE: could save a few mA by keeping clock off outside of at91_xfer... */
 281
 282 static int at91_i2c_suspend(struct platform_device *pdev, pm_message_t mesg)
 283 {
 284         clk_disable(twi_clk);
 285         return 0;
 286 }
 287
 288 static int at91_i2c_resume(struct platform_device *pdev)
 289 {
 290         return clk_enable(twi_clk);
 291 }
 292
 293 #else
 294 #define at91_i2c_suspend        NULL
 295 #define at91_i2c_resume         NULL
 296 #endif
 297
 298 static struct platform_driver at91_i2c_driver = {
 299         .probe          = at91_i2c_probe,
 300         .remove         = __devexit_p(at91_i2c_remove),
 301         .suspend        = at91_i2c_suspend,
 302         .resume         = at91_i2c_resume,
 303         .driver         = {
 304                 .name   = "at91_i2c",
 305                 .owner  = THIS_MODULE,
 306         },
 307 };
 308
 309 static int __init at91_i2c_init(void)
 310 {
 311         return platform_driver_register(&at91_i2c_driver);
 312 }
 313
 314 static void __exit at91_i2c_exit(void)
 315 {
 316         platform_driver_unregister(&at91_i2c_driver);
 317 }
 318
 319 module_init(at91_i2c_init);
 320 module_exit(at91_i2c_exit);
 321
 322 MODULE_AUTHOR("Rick Bronson");
 323 MODULE_DESCRIPTION("I2C (TWI) driver for Atmel AT91");
 324 MODULE_LICENSE("GPL");