drivers/i2c/busses/i2c-elektor.c

   1 /* ------------------------------------------------------------------------- */
   2 /* i2c-elektor.c i2c-hw access for PCF8584 style isa bus adaptes             */
   3 /* ------------------------------------------------------------------------- */
   4 /*   Copyright (C) 1995-97 Simon G. Vogl
   5                    1998-99 Hans Berglund
   6
   7     This program is free software; you can redistribute it and/or modify
   8     it under the terms of the GNU General Public License as published by
   9     the Free Software Foundation; either version 2 of the License, or
  10     (at your option) any later version.
  11
  12     This program is distributed in the hope that it will be useful,
  13     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15     GNU General Public License for more details.
  16
  17     You should have received a copy of the GNU General Public License
  18     along with this program; if not, write to the Free Software
  19     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                */
  20 /* ------------------------------------------------------------------------- */
  21
  22 /* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi> and even
  23    Frodo Looijaard <frodol@dds.nl> */
  24
  25 /* Partialy rewriten by Oleg I. Vdovikin for mmapped support of
  26    for Alpha Processor Inc. UP-2000(+) boards */
  27
  28 #include <linux/kernel.h>
  29 #include <linux/ioport.h>
  30 #include <linux/module.h>
  31 #include <linux/delay.h>
  32 #include <linux/slab.h>
  33 #include <linux/init.h>
  34 #include <linux/interrupt.h>
  35 #include <linux/pci.h>
  36 #include <linux/wait.h>
  37
  38 #include <linux/i2c.h>
  39 #include <linux/i2c-algo-pcf.h>
  40
  41 #include <asm/io.h>
  42 #include <asm/irq.h>
  43
  44 #include "../algos/i2c-algo-pcf.h"
  45
  46 #define DEFAULT_BASE 0x330
  47
  48 static int base;
  49 static u8 __iomem *base_iomem;
  50
  51 static int irq;
  52 static int clock  = 0x1c;
  53 static int own    = 0x55;
  54 static int mmapped;
  55
  56 /* vdovikin: removed static struct i2c_pcf_isa gpi; code -
  57   this module in real supports only one device, due to missing arguments
  58   in some functions, called from the algo-pcf module. Sometimes it's
  59   need to be rewriten - but for now just remove this for simpler reading */
  60
  61 static wait_queue_head_t pcf_wait;
  62 static int pcf_pending;
  63 static spinlock_t lock;
  64
  65 static struct i2c_adapter pcf_isa_ops;
  66
  67 /* ----- local functions ---------------------------------------------- */
  68
  69 static void pcf_isa_setbyte(void *data, int ctl, int val)
  70 {
  71         u8 __iomem *address = ctl ? (base_iomem + 1) : base_iomem;
  72
  73         /* enable irq if any specified for serial operation */
  74         if (ctl && irq && (val & I2C_PCF_ESO)) {
  75                 val |= I2C_PCF_ENI;
  76         }
  77
  78         pr_debug("%s: Write %p 0x%02X\n", pcf_isa_ops.name, address, val);
  79         iowrite8(val, address);
  80 #ifdef __alpha__
  81         /* API UP2000 needs some hardware fudging to make the write stick */
  82         iowrite8(val, address);
  83 #endif
  84 }
  85
  86 static int pcf_isa_getbyte(void *data, int ctl)
  87 {
  88         u8 __iomem *address = ctl ? (base_iomem + 1) : base_iomem;
  89         int val = ioread8(address);
  90
  91         pr_debug("%s: Read %p 0x%02X\n", pcf_isa_ops.name, address, val);
  92         return (val);
  93 }
  94
  95 static int pcf_isa_getown(void *data)
  96 {
  97         return (own);
  98 }
  99
 100
 101 static int pcf_isa_getclock(void *data)
 102 {
 103         return (clock);
 104 }
 105
 106 static void pcf_isa_waitforpin(void) {
 107         DEFINE_WAIT(wait);
 108         int timeout = 2;
 109         unsigned long flags;
 110
 111         if (irq > 0) {
 112                 spin_lock_irqsave(&lock, flags);
 113                 if (pcf_pending == 0) {
 114                         spin_unlock_irqrestore(&lock, flags);
 115                         prepare_to_wait(&pcf_wait, &wait, TASK_INTERRUPTIBLE);
 116                         if (schedule_timeout(timeout*HZ)) {
 117                                 spin_lock_irqsave(&lock, flags);
 118                                 if (pcf_pending == 1) {
 119                                         pcf_pending = 0;
 120                                 }
 121                                 spin_unlock_irqrestore(&lock, flags);
 122                         }
 123                         finish_wait(&pcf_wait, &wait);
 124                 } else {
 125                         pcf_pending = 0;
 126                         spin_unlock_irqrestore(&lock, flags);
 127                 }
 128         } else {
 129                 udelay(100);
 130         }
 131 }
 132
 133
 134 static irqreturn_t pcf_isa_handler(int this_irq, void *dev_id) {
 135         spin_lock(&lock);
 136         pcf_pending = 1;
 137         spin_unlock(&lock);
 138         wake_up_interruptible(&pcf_wait);
 139         return IRQ_HANDLED;
 140 }
 141
 142
 143 static int pcf_isa_init(void)
 144 {
 145         spin_lock_init(&lock);
 146         if (!mmapped) {
 147                 if (!request_region(base, 2, pcf_isa_ops.name)) {
 148                         printk(KERN_ERR "%s: requested I/O region (%#x:2) is "
 149                                "in use\n", pcf_isa_ops.name, base);
 150                         return -ENODEV;
 151                 }
 152                 base_iomem = ioport_map(base, 2);
 153                 if (!base_iomem) {
 154                         printk(KERN_ERR "%s: remap of I/O region %#x failed\n",
 155                                pcf_isa_ops.name, base);
 156                         release_region(base, 2);
 157                         return -ENODEV;
 158                 }
 159         } else {
 160                 if (!request_mem_region(base, 2, pcf_isa_ops.name)) {
 161                         printk(KERN_ERR "%s: requested memory region (%#x:2) "
 162                                "is in use\n", pcf_isa_ops.name, base);
 163                         return -ENODEV;
 164                 }
 165                 base_iomem = ioremap(base, 2);
 166                 if (base_iomem == NULL) {
 167                         printk(KERN_ERR "%s: remap of memory region %#x "
 168                                "failed\n", pcf_isa_ops.name, base);
 169                         release_mem_region(base, 2);
 170                         return -ENODEV;
 171                 }
 172         }
 173         pr_debug("%s: registers %#x remapped to %p\n", pcf_isa_ops.name, base,
 174                  base_iomem);
 175
 176         if (irq > 0) {
 177                 if (request_irq(irq, pcf_isa_handler, 0, pcf_isa_ops.name,
 178                                 NULL) < 0) {
 179                         printk(KERN_ERR "%s: Request irq%d failed\n",
 180                                pcf_isa_ops.name, irq);
 181                         irq = 0;
 182                 } else
 183                         enable_irq(irq);
 184         }
 185         return 0;
 186 }
 187
 188 /* ------------------------------------------------------------------------
 189  * Encapsulate the above functions in the correct operations structure.
 190  * This is only done when more than one hardware adapter is supported.
 191  */
 192 static struct i2c_algo_pcf_data pcf_isa_data = {
 193         .setpcf     = pcf_isa_setbyte,
 194         .getpcf     = pcf_isa_getbyte,
 195         .getown     = pcf_isa_getown,
 196         .getclock   = pcf_isa_getclock,
 197         .waitforpin = pcf_isa_waitforpin,
 198         .udelay     = 10,
 199         .timeout    = 100,
 200 };
 201
 202 static struct i2c_adapter pcf_isa_ops = {
 203         .owner          = THIS_MODULE,
 204         .class          = I2C_CLASS_HWMON,
 205         .id             = I2C_HW_P_ELEK,
 206         .algo_data      = &pcf_isa_data,
 207         .name           = "i2c-elektor",
 208 };
 209
 210 static int __init i2c_pcfisa_init(void)
 211 {
 212 #ifdef __alpha__
 213         /* check to see we have memory mapped PCF8584 connected to the
 214         Cypress cy82c693 PCI-ISA bridge as on UP2000 board */
 215         if (base == 0) {
 216                 struct pci_dev *cy693_dev;
 217
 218                 cy693_dev = pci_get_device(PCI_VENDOR_ID_CONTAQ,
 219                                            PCI_DEVICE_ID_CONTAQ_82C693, NULL);
 220                 if (cy693_dev) {
 221                         unsigned char config;
 222                         /* yeap, we've found cypress, let's check config */
 223                         if (!pci_read_config_byte(cy693_dev, 0x47, &config)) {
 224
 225                                 pr_debug("%s: found cy82c693, config "
 226                                          "register 0x47 = 0x%02x\n",
 227                                          pcf_isa_ops.name, config);
 228
 229                                 /* UP2000 board has this register set to 0xe1,
 230                                    but the most significant bit as seems can be
 231                                    reset during the proper initialisation
 232                                    sequence if guys from API decides to do that
 233                                    (so, we can even enable Tsunami Pchip
 234                                    window for the upper 1 Gb) */
 235
 236                                 /* so just check for ROMCS at 0xe0000,
 237                                    ROMCS enabled for writes
 238                                    and external XD Bus buffer in use. */
 239                                 if ((config & 0x7f) == 0x61) {
 240                                         /* seems to be UP2000 like board */
 241                                         base = 0xe0000;
 242                                         mmapped = 1;
 243                                         /* UP2000 drives ISA with
 244                                            8.25 MHz (PCI/4) clock
 245                                            (this can be read from cypress) */
 246                                         clock = I2C_PCF_CLK | I2C_PCF_TRNS90;
 247                                         pr_info("%s: found API UP2000 like "
 248                                                 "board, will probe PCF8584 "
 249                                                 "later\n", pcf_isa_ops.name);
 250                                 }
 251                         }
 252                         pci_dev_put(cy693_dev);
 253                 }
 254         }
 255 #endif
 256
 257         /* sanity checks for mmapped I/O */
 258         if (mmapped && base < 0xc8000) {
 259                 printk(KERN_ERR "%s: incorrect base address (%#x) specified "
 260                        "for mmapped I/O\n", pcf_isa_ops.name, base);
 261                 return -ENODEV;
 262         }
 263
 264         if (base == 0) {
 265                 base = DEFAULT_BASE;
 266         }
 267
 268         init_waitqueue_head(&pcf_wait);
 269         if (pcf_isa_init())
 270                 return -ENODEV;
 271         if (i2c_pcf_add_bus(&pcf_isa_ops) < 0)
 272                 goto fail;
 273
 274         dev_info(&pcf_isa_ops.dev, "found device at %#x\n", base);
 275
 276         return 0;
 277
 278  fail:
 279         if (irq > 0) {
 280                 disable_irq(irq);
 281                 free_irq(irq, NULL);
 282         }
 283
 284         if (!mmapped) {
 285                 ioport_unmap(base_iomem);
 286                 release_region(base, 2);
 287         } else {
 288                 iounmap(base_iomem);
 289                 release_mem_region(base, 2);
 290         }
 291         return -ENODEV;
 292 }
 293
 294 static void i2c_pcfisa_exit(void)
 295 {
 296         i2c_del_adapter(&pcf_isa_ops);
 297
 298         if (irq > 0) {
 299                 disable_irq(irq);
 300                 free_irq(irq, NULL);
 301         }
 302
 303         if (!mmapped) {
 304                 ioport_unmap(base_iomem);
 305                 release_region(base, 2);
 306         } else {
 307                 iounmap(base_iomem);
 308                 release_mem_region(base, 2);
 309         }
 310 }
 311
 312 MODULE_AUTHOR("Hans Berglund <hb@spacetec.no>");
 313 MODULE_DESCRIPTION("I2C-Bus adapter routines for PCF8584 ISA bus adapter");
 314 MODULE_LICENSE("GPL");
 315
 316 module_param(base, int, 0);
 317 module_param(irq, int, 0);
 318 module_param(clock, int, 0);
 319 module_param(own, int, 0);
 320 module_param(mmapped, int, 0);
 321
 322 module_init(i2c_pcfisa_init);
 323 module_exit(i2c_pcfisa_exit);