git.oblomov.eu Git - linux-2.6/blob - drivers/i2c/busses/i2c-mpc.c

   1 /*
   2  * (C) Copyright 2003-2004
   3  * Humboldt Solutions Ltd, adrian@humboldt.co.uk.
   4
   5  * This is a combined i2c adapter and algorithm driver for the
   6  * MPC107/Tsi107 PowerPC northbridge and processors that include
   7  * the same I2C unit (8240, 8245, 85xx).
   8  *
   9  * Release 0.8
  10  *
  11  * This file is licensed under the terms of the GNU General Public
  12  * License version 2. This program is licensed "as is" without any
  13  * warranty of any kind, whether express or implied.
  14  */
  15
  16 #include <linux/config.h>
  17 #include <linux/kernel.h>
  18 #include <linux/module.h>
  19 #include <linux/sched.h>
  20 #include <linux/init.h>
  21 #include <linux/pci.h>
  22 #include <asm/io.h>
  23 #include <linux/fsl_devices.h>
  24 #include <linux/i2c.h>
  25 #include <linux/interrupt.h>
  26 #include <linux/delay.h>
  27
  28 #define MPC_I2C_ADDR  0x00
  29 #define MPC_I2C_FDR     0x04
  30 #define MPC_I2C_CR      0x08
  31 #define MPC_I2C_SR      0x0c
  32 #define MPC_I2C_DR      0x10
  33 #define MPC_I2C_DFSRR 0x14
  34 #define MPC_I2C_REGION 0x20
  35
  36 #define CCR_MEN  0x80
  37 #define CCR_MIEN 0x40
  38 #define CCR_MSTA 0x20
  39 #define CCR_MTX  0x10
  40 #define CCR_TXAK 0x08
  41 #define CCR_RSTA 0x04
  42
  43 #define CSR_MCF  0x80
  44 #define CSR_MAAS 0x40
  45 #define CSR_MBB  0x20
  46 #define CSR_MAL  0x10
  47 #define CSR_SRW  0x04
  48 #define CSR_MIF  0x02
  49 #define CSR_RXAK 0x01
  50
  51 struct mpc_i2c {
  52         void __iomem *base;
  53         u32 interrupt;
  54         wait_queue_head_t queue;
  55         struct i2c_adapter adap;
  56         int irq;
  57         u32 flags;
  58 };
  59
  60 static __inline__ void writeccr(struct mpc_i2c *i2c, u32 x)
  61 {
  62         writeb(x, i2c->base + MPC_I2C_CR);
  63 }
  64
  65 static irqreturn_t mpc_i2c_isr(int irq, void *dev_id, struct pt_regs *regs)
  66 {
  67         struct mpc_i2c *i2c = dev_id;
  68         if (readb(i2c->base + MPC_I2C_SR) & CSR_MIF) {
  69                 /* Read again to allow register to stabilise */
  70                 i2c->interrupt = readb(i2c->base + MPC_I2C_SR);
  71                 writeb(0, i2c->base + MPC_I2C_SR);
  72                 wake_up_interruptible(&i2c->queue);
  73         }
  74         return IRQ_HANDLED;
  75 }
  76
  77 static int i2c_wait(struct mpc_i2c *i2c, unsigned timeout, int writing)
  78 {
  79         unsigned long orig_jiffies = jiffies;
  80         u32 x;
  81         int result = 0;
  82
  83         if (i2c->irq == 0)
  84         {
  85                 while (!(readb(i2c->base + MPC_I2C_SR) & CSR_MIF)) {
  86                         schedule();
  87                         if (time_after(jiffies, orig_jiffies + timeout)) {
  88                                 pr_debug("I2C: timeout\n");
  89                                 result = -EIO;
  90                                 break;
  91                         }
  92                 }
  93                 x = readb(i2c->base + MPC_I2C_SR);
  94                 writeb(0, i2c->base + MPC_I2C_SR);
  95         } else {
  96                 /* Interrupt mode */
  97                 result = wait_event_interruptible_timeout(i2c->queue,
  98                         (i2c->interrupt & CSR_MIF), timeout * HZ);
  99
 100                 if (unlikely(result < 0))
 101                         pr_debug("I2C: wait interrupted\n");
 102                 else if (unlikely(!(i2c->interrupt & CSR_MIF))) {
 103                         pr_debug("I2C: wait timeout\n");
 104                         result = -ETIMEDOUT;
 105                 }
 106
 107                 x = i2c->interrupt;
 108                 i2c->interrupt = 0;
 109         }
 110
 111         if (result < 0)
 112                 return result;
 113
 114         if (!(x & CSR_MCF)) {
 115                 pr_debug("I2C: unfinished\n");
 116                 return -EIO;
 117         }
 118
 119         if (x & CSR_MAL) {
 120                 pr_debug("I2C: MAL\n");
 121                 return -EIO;
 122         }
 123
 124         if (writing && (x & CSR_RXAK)) {
 125                 pr_debug("I2C: No RXAK\n");
 126                 /* generate stop */
 127                 writeccr(i2c, CCR_MEN);
 128                 return -EIO;
 129         }
 130         return 0;
 131 }
 132
 133 static void mpc_i2c_setclock(struct mpc_i2c *i2c)
 134 {
 135         /* Set clock and filters */
 136         if (i2c->flags & FSL_I2C_DEV_SEPARATE_DFSRR) {
 137                 writeb(0x31, i2c->base + MPC_I2C_FDR);
 138                 writeb(0x10, i2c->base + MPC_I2C_DFSRR);
 139         } else if (i2c->flags & FSL_I2C_DEV_CLOCK_5200)
 140                 writeb(0x3f, i2c->base + MPC_I2C_FDR);
 141         else
 142                 writel(0x1031, i2c->base + MPC_I2C_FDR);
 143 }
 144
 145 static void mpc_i2c_start(struct mpc_i2c *i2c)
 146 {
 147         /* Clear arbitration */
 148         writeb(0, i2c->base + MPC_I2C_SR);
 149         /* Start with MEN */
 150         writeccr(i2c, CCR_MEN);
 151 }
 152
 153 static void mpc_i2c_stop(struct mpc_i2c *i2c)
 154 {
 155         writeccr(i2c, CCR_MEN);
 156 }
 157
 158 static int mpc_write(struct mpc_i2c *i2c, int target,
 159                      const u8 * data, int length, int restart)
 160 {
 161         int i;
 162         unsigned timeout = i2c->adap.timeout;
 163         u32 flags = restart ? CCR_RSTA : 0;
 164
 165         /* Start with MEN */
 166         if (!restart)
 167                 writeccr(i2c, CCR_MEN);
 168         /* Start as master */
 169         writeccr(i2c, CCR_MIEN | CCR_MEN | CCR_MSTA | CCR_MTX | flags);
 170         /* Write target byte */
 171         writeb((target << 1), i2c->base + MPC_I2C_DR);
 172
 173         if (i2c_wait(i2c, timeout, 1) < 0)
 174                 return -1;
 175
 176         for (i = 0; i < length; i++) {
 177                 /* Write data byte */
 178                 writeb(data[i], i2c->base + MPC_I2C_DR);
 179
 180                 if (i2c_wait(i2c, timeout, 1) < 0)
 181                         return -1;
 182         }
 183
 184         return 0;
 185 }
 186
 187 static int mpc_read(struct mpc_i2c *i2c, int target,
 188                     u8 * data, int length, int restart)
 189 {
 190         unsigned timeout = i2c->adap.timeout;
 191         int i;
 192         u32 flags = restart ? CCR_RSTA : 0;
 193
 194         /* Start with MEN */
 195         if (!restart)
 196                 writeccr(i2c, CCR_MEN);
 197         /* Switch to read - restart */
 198         writeccr(i2c, CCR_MIEN | CCR_MEN | CCR_MSTA | CCR_MTX | flags);
 199         /* Write target address byte - this time with the read flag set */
 200         writeb((target << 1) | 1, i2c->base + MPC_I2C_DR);
 201
 202         if (i2c_wait(i2c, timeout, 1) < 0)
 203                 return -1;
 204
 205         if (length) {
 206                 if (length == 1)
 207                         writeccr(i2c, CCR_MIEN | CCR_MEN | CCR_MSTA | CCR_TXAK);
 208                 else
 209                         writeccr(i2c, CCR_MIEN | CCR_MEN | CCR_MSTA);
 210                 /* Dummy read */
 211                 readb(i2c->base + MPC_I2C_DR);
 212         }
 213
 214         for (i = 0; i < length; i++) {
 215                 if (i2c_wait(i2c, timeout, 0) < 0)
 216                         return -1;
 217
 218                 /* Generate txack on next to last byte */
 219                 if (i == length - 2)
 220                         writeccr(i2c, CCR_MIEN | CCR_MEN | CCR_MSTA | CCR_TXAK);
 221                 /* Generate stop on last byte */
 222                 if (i == length - 1)
 223                         writeccr(i2c, CCR_MIEN | CCR_MEN | CCR_TXAK);
 224                 data[i] = readb(i2c->base + MPC_I2C_DR);
 225         }
 226
 227         return length;
 228 }
 229
 230 static int mpc_xfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
 231 {
 232         struct i2c_msg *pmsg;
 233         int i;
 234         int ret = 0;
 235         unsigned long orig_jiffies = jiffies;
 236         struct mpc_i2c *i2c = i2c_get_adapdata(adap);
 237
 238         mpc_i2c_start(i2c);
 239
 240         /* Allow bus up to 1s to become not busy */
 241         while (readb(i2c->base + MPC_I2C_SR) & CSR_MBB) {
 242                 if (signal_pending(current)) {
 243                         pr_debug("I2C: Interrupted\n");
 244                         return -EINTR;
 245                 }
 246                 if (time_after(jiffies, orig_jiffies + HZ)) {
 247                         pr_debug("I2C: timeout\n");
 248                         return -EIO;
 249                 }
 250                 schedule();
 251         }
 252
 253         for (i = 0; ret >= 0 && i < num; i++) {
 254                 pmsg = &msgs[i];
 255                 pr_debug("Doing %s %d bytes to 0x%02x - %d of %d messages\n",
 256                          pmsg->flags & I2C_M_RD ? "read" : "write",
 257                          pmsg->len, pmsg->addr, i + 1, num);
 258                 if (pmsg->flags & I2C_M_RD)
 259                         ret =
 260                             mpc_read(i2c, pmsg->addr, pmsg->buf, pmsg->len, i);
 261                 else
 262                         ret =
 263                             mpc_write(i2c, pmsg->addr, pmsg->buf, pmsg->len, i);
 264         }
 265         mpc_i2c_stop(i2c);
 266         return (ret < 0) ? ret : num;
 267 }
 268
 269 static u32 mpc_functionality(struct i2c_adapter *adap)
 270 {
 271         return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
 272 }
 273
 274 static struct i2c_algorithm mpc_algo = {
 275         .name = "MPC algorithm",
 276         .id = I2C_ALGO_MPC107,
 277         .master_xfer = mpc_xfer,
 278         .functionality = mpc_functionality,
 279 };
 280
 281 static struct i2c_adapter mpc_ops = {
 282         .owner = THIS_MODULE,
 283         .name = "MPC adapter",
 284         .id = I2C_ALGO_MPC107 | I2C_HW_MPC107,
 285         .algo = &mpc_algo,
 286         .class = I2C_CLASS_HWMON,
 287         .timeout = 1,
 288         .retries = 1
 289 };
 290
 291 static int fsl_i2c_probe(struct device *device)
 292 {
 293         int result = 0;
 294         struct mpc_i2c *i2c;
 295         struct platform_device *pdev = to_platform_device(device);
 296         struct fsl_i2c_platform_data *pdata;
 297         struct resource *r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 298
 299         pdata = (struct fsl_i2c_platform_data *) pdev->dev.platform_data;
 300
 301         if (!(i2c = kmalloc(sizeof(*i2c), GFP_KERNEL))) {
 302                 return -ENOMEM;
 303         }
 304         memset(i2c, 0, sizeof(*i2c));
 305
 306         i2c->irq = platform_get_irq(pdev, 0);
 307         i2c->flags = pdata->device_flags;
 308         init_waitqueue_head(&i2c->queue);
 309
 310         i2c->base = ioremap((phys_addr_t)r->start, MPC_I2C_REGION);
 311
 312         if (!i2c->base) {
 313                 printk(KERN_ERR "i2c-mpc - failed to map controller\n");
 314                 result = -ENOMEM;
 315                 goto fail_map;
 316         }
 317
 318         if (i2c->irq != 0)
 319                 if ((result = request_irq(i2c->irq, mpc_i2c_isr,
 320                                           SA_SHIRQ, "i2c-mpc", i2c)) < 0) {
 321                         printk(KERN_ERR
 322                                "i2c-mpc - failed to attach interrupt\n");
 323                         goto fail_irq;
 324                 }
 325
 326         mpc_i2c_setclock(i2c);
 327         dev_set_drvdata(device, i2c);
 328
 329         i2c->adap = mpc_ops;
 330         i2c_set_adapdata(&i2c->adap, i2c);
 331         i2c->adap.dev.parent = &pdev->dev;
 332         if ((result = i2c_add_adapter(&i2c->adap)) < 0) {
 333                 printk(KERN_ERR "i2c-mpc - failed to add adapter\n");
 334                 goto fail_add;
 335         }
 336
 337         return result;
 338
 339       fail_add:
 340         if (i2c->irq != 0)
 341                 free_irq(i2c->irq, NULL);
 342       fail_irq:
 343         iounmap(i2c->base);
 344       fail_map:
 345         kfree(i2c);
 346         return result;
 347 };
 348
 349 static int fsl_i2c_remove(struct device *device)
 350 {
 351         struct mpc_i2c *i2c = dev_get_drvdata(device);
 352
 353         i2c_del_adapter(&i2c->adap);
 354         dev_set_drvdata(device, NULL);
 355
 356         if (i2c->irq != 0)
 357                 free_irq(i2c->irq, i2c);
 358
 359         iounmap(i2c->base);
 360         kfree(i2c);
 361         return 0;
 362 };
 363
 364 /* Structure for a device driver */
 365 static struct device_driver fsl_i2c_driver = {
 366         .name = "fsl-i2c",
 367         .bus = &platform_bus_type,
 368         .probe = fsl_i2c_probe,
 369         .remove = fsl_i2c_remove,
 370 };
 371
 372 static int __init fsl_i2c_init(void)
 373 {
 374         return driver_register(&fsl_i2c_driver);
 375 }
 376
 377 static void __exit fsl_i2c_exit(void)
 378 {
 379         driver_unregister(&fsl_i2c_driver);
 380 }
 381
 382 module_init(fsl_i2c_init);
 383 module_exit(fsl_i2c_exit);
 384
 385 static int fsl_i2c_probe(struct device *device)
 386 {
 387         int result = 0;
 388         struct mpc_i2c *i2c;
 389         struct platform_device *pdev = to_platform_device(device);
 390         struct fsl_i2c_platform_data *pdata;
 391         struct resource *r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 392
 393         pdata = (struct fsl_i2c_platform_data *) pdev->dev.platform_data;
 394
 395         if (!(i2c = kmalloc(sizeof(*i2c), GFP_KERNEL))) {
 396                 return -ENOMEM;
 397         }
 398         memset(i2c, 0, sizeof(*i2c));
 399
 400         i2c->irq = platform_get_irq(pdev, 0);
 401         i2c->flags = pdata->device_flags;
 402         init_waitqueue_head(&i2c->queue);
 403
 404         i2c->base = ioremap((phys_addr_t)r->start, MPC_I2C_REGION);
 405
 406         if (!i2c->base) {
 407                 printk(KERN_ERR "i2c-mpc - failed to map controller\n");
 408                 result = -ENOMEM;
 409                 goto fail_map;
 410         }
 411
 412         if (i2c->irq != 0)
 413                 if ((result = request_irq(i2c->irq, mpc_i2c_isr,
 414                                           SA_SHIRQ, "i2c-mpc", i2c)) < 0) {
 415                         printk(KERN_ERR
 416                                "i2c-mpc - failed to attach interrupt\n");
 417                         goto fail_irq;
 418                 }
 419
 420         mpc_i2c_setclock(i2c);
 421         dev_set_drvdata(device, i2c);
 422
 423         i2c->adap = mpc_ops;
 424         i2c_set_adapdata(&i2c->adap, i2c);
 425         i2c->adap.dev.parent = &pdev->dev;
 426         if ((result = i2c_add_adapter(&i2c->adap)) < 0) {
 427                 printk(KERN_ERR "i2c-mpc - failed to add adapter\n");
 428                 goto fail_add;
 429         }
 430
 431         return result;
 432
 433       fail_add:
 434         if (i2c->irq != 0)
 435                 free_irq(i2c->irq, NULL);
 436       fail_irq:
 437         iounmap(i2c->base);
 438       fail_map:
 439         kfree(i2c);
 440         return result;
 441 };
 442
 443 static int fsl_i2c_remove(struct device *device)
 444 {
 445         struct mpc_i2c *i2c = dev_get_drvdata(device);
 446
 447         i2c_del_adapter(&i2c->adap);
 448         dev_set_drvdata(device, NULL);
 449
 450         if (i2c->irq != 0)
 451                 free_irq(i2c->irq, i2c);
 452
 453         iounmap(i2c->base);
 454         kfree(i2c);
 455         return 0;
 456 };
 457
 458 /* Structure for a device driver */
 459 static struct device_driver fsl_i2c_driver = {
 460         .name = "fsl-i2c",
 461         .bus = &platform_bus_type,
 462         .probe = fsl_i2c_probe,
 463         .remove = fsl_i2c_remove,
 464 };
 465
 466 static int __init fsl_i2c_init(void)
 467 {
 468         return driver_register(&fsl_i2c_driver);
 469 }
 470
 471 static void __exit fsl_i2c_exit(void)
 472 {
 473         driver_unregister(&fsl_i2c_driver);
 474 }
 475
 476 module_init(fsl_i2c_init);
 477 module_exit(fsl_i2c_exit);
 478
 479 MODULE_AUTHOR("Adrian Cox <adrian@humboldt.co.uk>");
 480 MODULE_DESCRIPTION
 481     ("I2C-Bus adapter for MPC107 bridge and MPC824x/85xx/52xx processors");
 482 MODULE_LICENSE("GPL");