arch/powerpc/platforms/powermac/low_i2c.c

   1 /*
   2  *  arch/ppc/platforms/pmac_low_i2c.c
   3  *
   4  *  Copyright (C) 2003 Ben. Herrenschmidt (benh@kernel.crashing.org)
   5  *
   6  *  This program is free software; you can redistribute it and/or
   7  *  modify it under the terms of the GNU General Public License
   8  *  as published by the Free Software Foundation; either version
   9  *  2 of the License, or (at your option) any later version.
  10  *
  11  *  This file contains some low-level i2c access routines that
  12  *  need to be used by various bits of the PowerMac platform code
  13  *  at times where the real asynchronous & interrupt driven driver
  14  *  cannot be used. The API borrows some semantics from the darwin
  15  *  driver in order to ease the implementation of the platform
  16  *  properties parser
  17  */
  18
  19 #undef DEBUG
  20
  21 #include <linux/config.h>
  22 #include <linux/types.h>
  23 #include <linux/sched.h>
  24 #include <linux/init.h>
  25 #include <linux/module.h>
  26 #include <linux/adb.h>
  27 #include <linux/pmu.h>
  28 #include <asm/keylargo.h>
  29 #include <asm/uninorth.h>
  30 #include <asm/io.h>
  31 #include <asm/prom.h>
  32 #include <asm/machdep.h>
  33 #include <asm/pmac_low_i2c.h>
  34
  35 #define MAX_LOW_I2C_HOST        4
  36
  37 #ifdef DEBUG
  38 #define DBG(x...) do {\
  39                 printk(KERN_DEBUG "KW:" x);     \
  40         } while(0)
  41 #else
  42 #define DBG(x...)
  43 #endif
  44
  45 struct low_i2c_host;
  46
  47 typedef int (*low_i2c_func_t)(struct low_i2c_host *host, u8 addr, u8 sub, u8 *data, int len);
  48
  49 struct low_i2c_host
  50 {
  51         struct device_node      *np;            /* OF device node */
  52         struct semaphore        mutex;          /* Access mutex for use by i2c-keywest */
  53         low_i2c_func_t          func;           /* Access function */
  54         unsigned int            is_open : 1;    /* Poor man's access control */
  55         int                     mode;           /* Current mode */
  56         int                     channel;        /* Current channel */
  57         int                     num_channels;   /* Number of channels */
  58         void __iomem            *base;          /* For keywest-i2c, base address */
  59         int                     bsteps;         /* And register stepping */
  60         int                     speed;          /* And speed */
  61 };
  62
  63 static struct low_i2c_host      low_i2c_hosts[MAX_LOW_I2C_HOST];
  64
  65 /* No locking is necessary on allocation, we are running way before
  66  * anything can race with us
  67  */
  68 static struct low_i2c_host *find_low_i2c_host(struct device_node *np)
  69 {
  70         int i;
  71
  72         for (i = 0; i < MAX_LOW_I2C_HOST; i++)
  73                 if (low_i2c_hosts[i].np == np)
  74                         return &low_i2c_hosts[i];
  75         return NULL;
  76 }
  77
  78 /*
  79  *
  80  * i2c-keywest implementation (UniNorth, U2, U3, Keylargo's)
  81  *
  82  */
  83
  84 /*
  85  * Keywest i2c definitions borrowed from drivers/i2c/i2c-keywest.h,
  86  * should be moved somewhere in include/asm-ppc/
  87  */
  88 /* Register indices */
  89 typedef enum {
  90         reg_mode = 0,
  91         reg_control,
  92         reg_status,
  93         reg_isr,
  94         reg_ier,
  95         reg_addr,
  96         reg_subaddr,
  97         reg_data
  98 } reg_t;
  99
 100
 101 /* Mode register */
 102 #define KW_I2C_MODE_100KHZ      0x00
 103 #define KW_I2C_MODE_50KHZ       0x01
 104 #define KW_I2C_MODE_25KHZ       0x02
 105 #define KW_I2C_MODE_DUMB        0x00
 106 #define KW_I2C_MODE_STANDARD    0x04
 107 #define KW_I2C_MODE_STANDARDSUB 0x08
 108 #define KW_I2C_MODE_COMBINED    0x0C
 109 #define KW_I2C_MODE_MODE_MASK   0x0C
 110 #define KW_I2C_MODE_CHAN_MASK   0xF0
 111
 112 /* Control register */
 113 #define KW_I2C_CTL_AAK          0x01
 114 #define KW_I2C_CTL_XADDR        0x02
 115 #define KW_I2C_CTL_STOP         0x04
 116 #define KW_I2C_CTL_START        0x08
 117
 118 /* Status register */
 119 #define KW_I2C_STAT_BUSY        0x01
 120 #define KW_I2C_STAT_LAST_AAK    0x02
 121 #define KW_I2C_STAT_LAST_RW     0x04
 122 #define KW_I2C_STAT_SDA         0x08
 123 #define KW_I2C_STAT_SCL         0x10
 124
 125 /* IER & ISR registers */
 126 #define KW_I2C_IRQ_DATA         0x01
 127 #define KW_I2C_IRQ_ADDR         0x02
 128 #define KW_I2C_IRQ_STOP         0x04
 129 #define KW_I2C_IRQ_START        0x08
 130 #define KW_I2C_IRQ_MASK         0x0F
 131
 132 /* State machine states */
 133 enum {
 134         state_idle,
 135         state_addr,
 136         state_read,
 137         state_write,
 138         state_stop,
 139         state_dead
 140 };
 141
 142 #define WRONG_STATE(name) do {\
 143                 printk(KERN_DEBUG "KW: wrong state. Got %s, state: %s (isr: %02x)\n", \
 144                        name, __kw_state_names[state], isr); \
 145         } while(0)
 146
 147 static const char *__kw_state_names[] = {
 148         "state_idle",
 149         "state_addr",
 150         "state_read",
 151         "state_write",
 152         "state_stop",
 153         "state_dead"
 154 };
 155
 156 static inline u8 __kw_read_reg(struct low_i2c_host *host, reg_t reg)
 157 {
 158         return readb(host->base + (((unsigned int)reg) << host->bsteps));
 159 }
 160
 161 static inline void __kw_write_reg(struct low_i2c_host *host, reg_t reg, u8 val)
 162 {
 163         writeb(val, host->base + (((unsigned)reg) << host->bsteps));
 164         (void)__kw_read_reg(host, reg_subaddr);
 165 }
 166
 167 #define kw_write_reg(reg, val)  __kw_write_reg(host, reg, val)
 168 #define kw_read_reg(reg)        __kw_read_reg(host, reg)
 169
 170
 171 /* Don't schedule, the g5 fan controller is too
 172  * timing sensitive
 173  */
 174 static u8 kw_wait_interrupt(struct low_i2c_host* host)
 175 {
 176         int i, j;
 177         u8 isr;
 178
 179         for (i = 0; i < 100000; i++) {
 180                 isr = kw_read_reg(reg_isr) & KW_I2C_IRQ_MASK;
 181                 if (isr != 0)
 182                         return isr;
 183
 184                 /* This code is used with the timebase frozen, we cannot rely
 185                  * on udelay ! For now, just use a bogus loop
 186                  */
 187                 for (j = 1; j < 10000; j++)
 188                         mb();
 189         }
 190         return isr;
 191 }
 192
 193 static int kw_handle_interrupt(struct low_i2c_host *host, int state, int rw, int *rc, u8 **data, int *len, u8 isr)
 194 {
 195         u8 ack;
 196
 197         DBG("kw_handle_interrupt(%s, isr: %x)\n", __kw_state_names[state], isr);
 198
 199         if (isr == 0) {
 200                 if (state != state_stop) {
 201                         DBG("KW: Timeout !\n");
 202                         *rc = -EIO;
 203                         goto stop;
 204                 }
 205                 if (state == state_stop) {
 206                         ack = kw_read_reg(reg_status);
 207                         if (!(ack & KW_I2C_STAT_BUSY)) {
 208                                 state = state_idle;
 209                                 kw_write_reg(reg_ier, 0x00);
 210                         }
 211                 }
 212                 return state;
 213         }
 214
 215         if (isr & KW_I2C_IRQ_ADDR) {
 216                 ack = kw_read_reg(reg_status);
 217                 if (state != state_addr) {
 218                         kw_write_reg(reg_isr, KW_I2C_IRQ_ADDR);
 219                         WRONG_STATE("KW_I2C_IRQ_ADDR");
 220                         *rc = -EIO;
 221                         goto stop;
 222                 }
 223                 if ((ack & KW_I2C_STAT_LAST_AAK) == 0) {
 224                         *rc = -ENODEV;
 225                         DBG("KW: NAK on address\n");
 226                         return state_stop;
 227                 } else {
 228                         if (rw) {
 229                                 state = state_read;
 230                                 if (*len > 1)
 231                                         kw_write_reg(reg_control, KW_I2C_CTL_AAK);
 232                         } else {
 233                                 state = state_write;
 234                                 kw_write_reg(reg_data, **data);
 235                                 (*data)++; (*len)--;
 236                         }
 237                 }
 238                 kw_write_reg(reg_isr, KW_I2C_IRQ_ADDR);
 239         }
 240
 241         if (isr & KW_I2C_IRQ_DATA) {
 242                 if (state == state_read) {
 243                         **data = kw_read_reg(reg_data);
 244                         (*data)++; (*len)--;
 245                         kw_write_reg(reg_isr, KW_I2C_IRQ_DATA);
 246                         if ((*len) == 0)
 247                                 state = state_stop;
 248                         else if ((*len) == 1)
 249                                 kw_write_reg(reg_control, 0);
 250                 } else if (state == state_write) {
 251                         ack = kw_read_reg(reg_status);
 252                         if ((ack & KW_I2C_STAT_LAST_AAK) == 0) {
 253                                 DBG("KW: nack on data write\n");
 254                                 *rc = -EIO;
 255                                 goto stop;
 256                         } else if (*len) {
 257                                 kw_write_reg(reg_data, **data);
 258                                 (*data)++; (*len)--;
 259                         } else {
 260                                 kw_write_reg(reg_control, KW_I2C_CTL_STOP);
 261                                 state = state_stop;
 262                                 *rc = 0;
 263                         }
 264                         kw_write_reg(reg_isr, KW_I2C_IRQ_DATA);
 265                 } else {
 266                         kw_write_reg(reg_isr, KW_I2C_IRQ_DATA);
 267                         WRONG_STATE("KW_I2C_IRQ_DATA");
 268                         if (state != state_stop) {
 269                                 *rc = -EIO;
 270                                 goto stop;
 271                         }
 272                 }
 273         }
 274
 275         if (isr & KW_I2C_IRQ_STOP) {
 276                 kw_write_reg(reg_isr, KW_I2C_IRQ_STOP);
 277                 if (state != state_stop) {
 278                         WRONG_STATE("KW_I2C_IRQ_STOP");
 279                         *rc = -EIO;
 280                 }
 281                 return state_idle;
 282         }
 283
 284         if (isr & KW_I2C_IRQ_START)
 285                 kw_write_reg(reg_isr, KW_I2C_IRQ_START);
 286
 287         return state;
 288
 289  stop:
 290         kw_write_reg(reg_control, KW_I2C_CTL_STOP);
 291         return state_stop;
 292 }
 293
 294 static int keywest_low_i2c_func(struct low_i2c_host *host, u8 addr, u8 subaddr, u8 *data, int len)
 295 {
 296         u8 mode_reg = host->speed;
 297         int state = state_addr;
 298         int rc = 0;
 299
 300         /* Setup mode & subaddress if any */
 301         switch(host->mode) {
 302         case pmac_low_i2c_mode_dumb:
 303                 printk(KERN_ERR "low_i2c: Dumb mode not supported !\n");
 304                 return -EINVAL;
 305         case pmac_low_i2c_mode_std:
 306                 mode_reg |= KW_I2C_MODE_STANDARD;
 307                 break;
 308         case pmac_low_i2c_mode_stdsub:
 309                 mode_reg |= KW_I2C_MODE_STANDARDSUB;
 310                 break;
 311         case pmac_low_i2c_mode_combined:
 312                 mode_reg |= KW_I2C_MODE_COMBINED;
 313                 break;
 314         }
 315
 316         /* Setup channel & clear pending irqs */
 317         kw_write_reg(reg_isr, kw_read_reg(reg_isr));
 318         kw_write_reg(reg_mode, mode_reg | (host->channel << 4));
 319         kw_write_reg(reg_status, 0);
 320
 321         /* Set up address and r/w bit */
 322         kw_write_reg(reg_addr, addr);
 323
 324         /* Set up the sub address */
 325         if ((mode_reg & KW_I2C_MODE_MODE_MASK) == KW_I2C_MODE_STANDARDSUB
 326             || (mode_reg & KW_I2C_MODE_MODE_MASK) == KW_I2C_MODE_COMBINED)
 327                 kw_write_reg(reg_subaddr, subaddr);
 328
 329         /* Start sending address & disable interrupt*/
 330         kw_write_reg(reg_ier, 0 /*KW_I2C_IRQ_MASK*/);
 331         kw_write_reg(reg_control, KW_I2C_CTL_XADDR);
 332
 333         /* State machine, to turn into an interrupt handler */
 334         while(state != state_idle) {
 335                 u8 isr = kw_wait_interrupt(host);
 336                 state = kw_handle_interrupt(host, state, addr & 1, &rc, &data, &len, isr);
 337         }
 338
 339         return rc;
 340 }
 341
 342 static void keywest_low_i2c_add(struct device_node *np)
 343 {
 344         struct low_i2c_host     *host = find_low_i2c_host(NULL);
 345         u32                     *psteps, *prate, steps, aoffset = 0;
 346         struct device_node      *parent;
 347
 348         if (host == NULL) {
 349                 printk(KERN_ERR "low_i2c: Can't allocate host for %s\n",
 350                        np->full_name);
 351                 return;
 352         }
 353         memset(host, 0, sizeof(*host));
 354
 355         init_MUTEX(&host->mutex);
 356         host->np = of_node_get(np);
 357         psteps = (u32 *)get_property(np, "AAPL,address-step", NULL);
 358         steps = psteps ? (*psteps) : 0x10;
 359         for (host->bsteps = 0; (steps & 0x01) == 0; host->bsteps++)
 360                 steps >>= 1;
 361         parent = of_get_parent(np);
 362         host->num_channels = 1;
 363         if (parent && parent->name[0] == 'u') {
 364                 host->num_channels = 2;
 365                 aoffset = 3;
 366         }
 367         /* Select interface rate */
 368         host->speed = KW_I2C_MODE_100KHZ;
 369         prate = (u32 *)get_property(np, "AAPL,i2c-rate", NULL);
 370         if (prate) switch(*prate) {
 371         case 100:
 372                 host->speed = KW_I2C_MODE_100KHZ;
 373                 break;
 374         case 50:
 375                 host->speed = KW_I2C_MODE_50KHZ;
 376                 break;
 377         case 25:
 378                 host->speed = KW_I2C_MODE_25KHZ;
 379                 break;
 380         }
 381
 382         host->mode = pmac_low_i2c_mode_std;
 383         host->base = ioremap(np->addrs[0].address + aoffset,
 384                                                 np->addrs[0].size);
 385         host->func = keywest_low_i2c_func;
 386 }
 387
 388 /*
 389  *
 390  * PMU implementation
 391  *
 392  */
 393
 394
 395 #ifdef CONFIG_ADB_PMU
 396
 397 static int pmu_low_i2c_func(struct low_i2c_host *host, u8 addr, u8 sub, u8 *data, int len)
 398 {
 399         // TODO
 400         return -ENODEV;
 401 }
 402
 403 static void pmu_low_i2c_add(struct device_node *np)
 404 {
 405         struct low_i2c_host     *host = find_low_i2c_host(NULL);
 406
 407         if (host == NULL) {
 408                 printk(KERN_ERR "low_i2c: Can't allocate host for %s\n",
 409                        np->full_name);
 410                 return;
 411         }
 412         memset(host, 0, sizeof(*host));
 413
 414         init_MUTEX(&host->mutex);
 415         host->np = of_node_get(np);
 416         host->num_channels = 3;
 417         host->mode = pmac_low_i2c_mode_std;
 418         host->func = pmu_low_i2c_func;
 419 }
 420
 421 #endif /* CONFIG_ADB_PMU */
 422
 423 void __init pmac_init_low_i2c(void)
 424 {
 425         struct device_node *np;
 426
 427         /* Probe keywest-i2c busses */
 428         np = of_find_compatible_node(NULL, "i2c", "keywest-i2c");
 429         while(np) {
 430                 keywest_low_i2c_add(np);
 431                 np = of_find_compatible_node(np, "i2c", "keywest-i2c");
 432         }
 433
 434 #ifdef CONFIG_ADB_PMU
 435         /* Probe PMU busses */
 436         np = of_find_node_by_name(NULL, "via-pmu");
 437         if (np)
 438                 pmu_low_i2c_add(np);
 439 #endif /* CONFIG_ADB_PMU */
 440
 441         /* TODO: Add CUDA support as well */
 442 }
 443
 444 int pmac_low_i2c_lock(struct device_node *np)
 445 {
 446         struct low_i2c_host *host = find_low_i2c_host(np);
 447
 448         if (!host)
 449                 return -ENODEV;
 450         down(&host->mutex);
 451         return 0;
 452 }
 453 EXPORT_SYMBOL(pmac_low_i2c_lock);
 454
 455 int pmac_low_i2c_unlock(struct device_node *np)
 456 {
 457         struct low_i2c_host *host = find_low_i2c_host(np);
 458
 459         if (!host)
 460                 return -ENODEV;
 461         up(&host->mutex);
 462         return 0;
 463 }
 464 EXPORT_SYMBOL(pmac_low_i2c_unlock);
 465
 466
 467 int pmac_low_i2c_open(struct device_node *np, int channel)
 468 {
 469         struct low_i2c_host *host = find_low_i2c_host(np);
 470
 471         if (!host)
 472                 return -ENODEV;
 473
 474         if (channel >= host->num_channels)
 475                 return -EINVAL;
 476
 477         down(&host->mutex);
 478         host->is_open = 1;
 479         host->channel = channel;
 480
 481         return 0;
 482 }
 483 EXPORT_SYMBOL(pmac_low_i2c_open);
 484
 485 int pmac_low_i2c_close(struct device_node *np)
 486 {
 487         struct low_i2c_host *host = find_low_i2c_host(np);
 488
 489         if (!host)
 490                 return -ENODEV;
 491
 492         host->is_open = 0;
 493         up(&host->mutex);
 494
 495         return 0;
 496 }
 497 EXPORT_SYMBOL(pmac_low_i2c_close);
 498
 499 int pmac_low_i2c_setmode(struct device_node *np, int mode)
 500 {
 501         struct low_i2c_host *host = find_low_i2c_host(np);
 502
 503         if (!host)
 504                 return -ENODEV;
 505         WARN_ON(!host->is_open);
 506         host->mode = mode;
 507
 508         return 0;
 509 }
 510 EXPORT_SYMBOL(pmac_low_i2c_setmode);
 511
 512 int pmac_low_i2c_xfer(struct device_node *np, u8 addrdir, u8 subaddr, u8 *data, int len)
 513 {
 514         struct low_i2c_host *host = find_low_i2c_host(np);
 515
 516         if (!host)
 517                 return -ENODEV;
 518         WARN_ON(!host->is_open);
 519
 520         return host->func(host, addrdir, subaddr, data, len);
 521 }
 522 EXPORT_SYMBOL(pmac_low_i2c_xfer);
 523