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, struct pt_regs *regs) {
 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         .mdelay     = 10,
 200         .timeout    = 100,
 201 };
 202
 203 static struct i2c_adapter pcf_isa_ops = {
 204         .owner          = THIS_MODULE,
 205         .class          = I2C_CLASS_HWMON,
 206         .id             = I2C_HW_P_ELEK,
 207         .algo_data      = &pcf_isa_data,
 208         .name           = "i2c-elektor",
 209 };
 210
 211 static int __init i2c_pcfisa_init(void)
 212 {
 213 #ifdef __alpha__
 214         /* check to see we have memory mapped PCF8584 connected to the
 215         Cypress cy82c693 PCI-ISA bridge as on UP2000 board */
 216         if (base == 0) {
 217                 struct pci_dev *cy693_dev;
 218
 219                 cy693_dev = pci_get_device(PCI_VENDOR_ID_CONTAQ,
 220                                            PCI_DEVICE_ID_CONTAQ_82C693, NULL);
 221                 if (cy693_dev) {
 222                         unsigned char config;
 223                         /* yeap, we've found cypress, let's check config */
 224                         if (!pci_read_config_byte(cy693_dev, 0x47, &config)) {
 225
 226                                 pr_debug("%s: found cy82c693, config "
 227                                          "register 0x47 = 0x%02x\n",
 228                                          pcf_isa_ops.name, config);
 229
 230                                 /* UP2000 board has this register set to 0xe1,
 231                                    but the most significant bit as seems can be
 232                                    reset during the proper initialisation
 233                                    sequence if guys from API decides to do that
 234                                    (so, we can even enable Tsunami Pchip
 235                                    window for the upper 1 Gb) */
 236
 237                                 /* so just check for ROMCS at 0xe0000,
 238                                    ROMCS enabled for writes
 239                                    and external XD Bus buffer in use. */
 240                                 if ((config & 0x7f) == 0x61) {
 241                                         /* seems to be UP2000 like board */
 242                                         base = 0xe0000;
 243                                         mmapped = 1;
 244                                         /* UP2000 drives ISA with
 245                                            8.25 MHz (PCI/4) clock
 246                                            (this can be read from cypress) */
 247                                         clock = I2C_PCF_CLK | I2C_PCF_TRNS90;
 248                                         pr_info("%s: found API UP2000 like "
 249                                                 "board, will probe PCF8584 "
 250                                                 "later\n", pcf_isa_ops.name);
 251                                 }
 252                         }
 253                         pci_dev_put(cy693_dev);
 254                 }
 255         }
 256 #endif
 257
 258         /* sanity checks for mmapped I/O */
 259         if (mmapped && base < 0xc8000) {
 260                 printk(KERN_ERR "%s: incorrect base address (%#x) specified "
 261                        "for mmapped I/O\n", pcf_isa_ops.name, base);
 262                 return -ENODEV;
 263         }
 264
 265         if (base == 0) {
 266                 base = DEFAULT_BASE;
 267         }
 268
 269         init_waitqueue_head(&pcf_wait);
 270         if (pcf_isa_init())
 271                 return -ENODEV;
 272         if (i2c_pcf_add_bus(&pcf_isa_ops) < 0)
 273                 goto fail;
 274
 275         dev_info(&pcf_isa_ops.dev, "found device at %#x\n", base);
 276
 277         return 0;
 278
 279  fail:
 280         if (irq > 0) {
 281                 disable_irq(irq);
 282                 free_irq(irq, NULL);
 283         }
 284
 285         if (!mmapped) {
 286                 ioport_unmap(base_iomem);
 287                 release_region(base, 2);
 288         } else {
 289                 iounmap(base_iomem);
 290                 release_mem_region(base, 2);
 291         }
 292         return -ENODEV;
 293 }
 294
 295 static void i2c_pcfisa_exit(void)
 296 {
 297         i2c_pcf_del_bus(&pcf_isa_ops);
 298
 299         if (irq > 0) {
 300                 disable_irq(irq);
 301                 free_irq(irq, NULL);
 302         }
 303
 304         if (!mmapped) {
 305                 ioport_unmap(base_iomem);
 306                 release_region(base, 2);
 307         } else {
 308                 iounmap(base_iomem);
 309                 release_mem_region(base, 2);
 310         }
 311 }
 312
 313 MODULE_AUTHOR("Hans Berglund <hb@spacetec.no>");
 314 MODULE_DESCRIPTION("I2C-Bus adapter routines for PCF8584 ISA bus adapter");
 315 MODULE_LICENSE("GPL");
 316
 317 module_param(base, int, 0);
 318 module_param(irq, int, 0);
 319 module_param(clock, int, 0);
 320 module_param(own, int, 0);
 321 module_param(mmapped, int, 0);
 322
 323 module_init(i2c_pcfisa_init);
 324 module_exit(i2c_pcfisa_exit);