git.oblomov.eu Git - linux-2.6/blob - 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/isa.h>
  39 #include <linux/i2c.h>
  40 #include <linux/i2c-algo-pcf.h>
  41
  42 #include <asm/io.h>
  43 #include <asm/irq.h>
  44
  45 #include "../algos/i2c-algo-pcf.h"
  46
  47 #define DEFAULT_BASE 0x330
  48
  49 static int base;
  50 static u8 __iomem *base_iomem;
  51
  52 static int irq;
  53 static int clock  = 0x1c;
  54 static int own    = 0x55;
  55 static int mmapped;
  56
  57 /* vdovikin: removed static struct i2c_pcf_isa gpi; code -
  58   this module in real supports only one device, due to missing arguments
  59   in some functions, called from the algo-pcf module. Sometimes it's
  60   need to be rewriten - but for now just remove this for simpler reading */
  61
  62 static wait_queue_head_t pcf_wait;
  63 static int pcf_pending;
  64 static spinlock_t lock;
  65
  66 static struct i2c_adapter pcf_isa_ops;
  67
  68 /* ----- local functions ---------------------------------------------- */
  69
  70 static void pcf_isa_setbyte(void *data, int ctl, int val)
  71 {
  72         u8 __iomem *address = ctl ? (base_iomem + 1) : base_iomem;
  73
  74         /* enable irq if any specified for serial operation */
  75         if (ctl && irq && (val & I2C_PCF_ESO)) {
  76                 val |= I2C_PCF_ENI;
  77         }
  78
  79         pr_debug("%s: Write %p 0x%02X\n", pcf_isa_ops.name, address, val);
  80         iowrite8(val, address);
  81 #ifdef __alpha__
  82         /* API UP2000 needs some hardware fudging to make the write stick */
  83         iowrite8(val, address);
  84 #endif
  85 }
  86
  87 static int pcf_isa_getbyte(void *data, int ctl)
  88 {
  89         u8 __iomem *address = ctl ? (base_iomem + 1) : base_iomem;
  90         int val = ioread8(address);
  91
  92         pr_debug("%s: Read %p 0x%02X\n", pcf_isa_ops.name, address, val);
  93         return (val);
  94 }
  95
  96 static int pcf_isa_getown(void *data)
  97 {
  98         return (own);
  99 }
 100
 101
 102 static int pcf_isa_getclock(void *data)
 103 {
 104         return (clock);
 105 }
 106
 107 static void pcf_isa_waitforpin(void *data)
 108 {
 109         DEFINE_WAIT(wait);
 110         int timeout = 2;
 111         unsigned long flags;
 112
 113         if (irq > 0) {
 114                 spin_lock_irqsave(&lock, flags);
 115                 if (pcf_pending == 0) {
 116                         spin_unlock_irqrestore(&lock, flags);
 117                         prepare_to_wait(&pcf_wait, &wait, TASK_INTERRUPTIBLE);
 118                         if (schedule_timeout(timeout*HZ)) {
 119                                 spin_lock_irqsave(&lock, flags);
 120                                 if (pcf_pending == 1) {
 121                                         pcf_pending = 0;
 122                                 }
 123                                 spin_unlock_irqrestore(&lock, flags);
 124                         }
 125                         finish_wait(&pcf_wait, &wait);
 126                 } else {
 127                         pcf_pending = 0;
 128                         spin_unlock_irqrestore(&lock, flags);
 129                 }
 130         } else {
 131                 udelay(100);
 132         }
 133 }
 134
 135
 136 static irqreturn_t pcf_isa_handler(int this_irq, void *dev_id) {
 137         spin_lock(&lock);
 138         pcf_pending = 1;
 139         spin_unlock(&lock);
 140         wake_up_interruptible(&pcf_wait);
 141         return IRQ_HANDLED;
 142 }
 143
 144
 145 static int pcf_isa_init(void)
 146 {
 147         spin_lock_init(&lock);
 148         if (!mmapped) {
 149                 if (!request_region(base, 2, pcf_isa_ops.name)) {
 150                         printk(KERN_ERR "%s: requested I/O region (%#x:2) is "
 151                                "in use\n", pcf_isa_ops.name, base);
 152                         return -ENODEV;
 153                 }
 154                 base_iomem = ioport_map(base, 2);
 155                 if (!base_iomem) {
 156                         printk(KERN_ERR "%s: remap of I/O region %#x failed\n",
 157                                pcf_isa_ops.name, base);
 158                         release_region(base, 2);
 159                         return -ENODEV;
 160                 }
 161         } else {
 162                 if (!request_mem_region(base, 2, pcf_isa_ops.name)) {
 163                         printk(KERN_ERR "%s: requested memory region (%#x:2) "
 164                                "is in use\n", pcf_isa_ops.name, base);
 165                         return -ENODEV;
 166                 }
 167                 base_iomem = ioremap(base, 2);
 168                 if (base_iomem == NULL) {
 169                         printk(KERN_ERR "%s: remap of memory region %#x "
 170                                "failed\n", pcf_isa_ops.name, base);
 171                         release_mem_region(base, 2);
 172                         return -ENODEV;
 173                 }
 174         }
 175         pr_debug("%s: registers %#x remapped to %p\n", pcf_isa_ops.name, base,
 176                  base_iomem);
 177
 178         if (irq > 0) {
 179                 if (request_irq(irq, pcf_isa_handler, 0, pcf_isa_ops.name,
 180                                 NULL) < 0) {
 181                         printk(KERN_ERR "%s: Request irq%d failed\n",
 182                                pcf_isa_ops.name, irq);
 183                         irq = 0;
 184                 } else
 185                         enable_irq(irq);
 186         }
 187         return 0;
 188 }
 189
 190 /* ------------------------------------------------------------------------
 191  * Encapsulate the above functions in the correct operations structure.
 192  * This is only done when more than one hardware adapter is supported.
 193  */
 194 static struct i2c_algo_pcf_data pcf_isa_data = {
 195         .setpcf     = pcf_isa_setbyte,
 196         .getpcf     = pcf_isa_getbyte,
 197         .getown     = pcf_isa_getown,
 198         .getclock   = pcf_isa_getclock,
 199         .waitforpin = pcf_isa_waitforpin,
 200 };
 201
 202 static struct i2c_adapter pcf_isa_ops = {
 203         .owner          = THIS_MODULE,
 204         .class          = I2C_CLASS_HWMON | I2C_CLASS_SPD,
 205         .id             = I2C_HW_P_ELEK,
 206         .algo_data      = &pcf_isa_data,
 207         .name           = "i2c-elektor",
 208 };
 209
 210 static int __devinit elektor_match(struct device *dev, unsigned int id)
 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                                 dev_dbg(dev, "found cy82c693, config "
 226                                         "register 0x47 = 0x%02x\n", config);
 227
 228                                 /* UP2000 board has this register set to 0xe1,
 229                                    but the most significant bit as seems can be
 230                                    reset during the proper initialisation
 231                                    sequence if guys from API decides to do that
 232                                    (so, we can even enable Tsunami Pchip
 233                                    window for the upper 1 Gb) */
 234
 235                                 /* so just check for ROMCS at 0xe0000,
 236                                    ROMCS enabled for writes
 237                                    and external XD Bus buffer in use. */
 238                                 if ((config & 0x7f) == 0x61) {
 239                                         /* seems to be UP2000 like board */
 240                                         base = 0xe0000;
 241                                         mmapped = 1;
 242                                         /* UP2000 drives ISA with
 243                                            8.25 MHz (PCI/4) clock
 244                                            (this can be read from cypress) */
 245                                         clock = I2C_PCF_CLK | I2C_PCF_TRNS90;
 246                                         dev_info(dev, "found API UP2000 like "
 247                                                  "board, will probe PCF8584 "
 248                                                  "later\n");
 249                                 }
 250                         }
 251                         pci_dev_put(cy693_dev);
 252                 }
 253         }
 254 #endif
 255
 256         /* sanity checks for mmapped I/O */
 257         if (mmapped && base < 0xc8000) {
 258                 dev_err(dev, "incorrect base address (%#x) specified "
 259                        "for mmapped I/O\n", base);
 260                 return 0;
 261         }
 262
 263         if (base == 0) {
 264                 base = DEFAULT_BASE;
 265         }
 266         return 1;
 267 }
 268
 269 static int __devinit elektor_probe(struct device *dev, unsigned int id)
 270 {
 271         init_waitqueue_head(&pcf_wait);
 272         if (pcf_isa_init())
 273                 return -ENODEV;
 274         pcf_isa_ops.dev.parent = dev;
 275         if (i2c_pcf_add_bus(&pcf_isa_ops) < 0)
 276                 goto fail;
 277
 278         dev_info(dev, "found device at %#x\n", base);
 279
 280         return 0;
 281
 282  fail:
 283         if (irq > 0) {
 284                 disable_irq(irq);
 285                 free_irq(irq, NULL);
 286         }
 287
 288         if (!mmapped) {
 289                 ioport_unmap(base_iomem);
 290                 release_region(base, 2);
 291         } else {
 292                 iounmap(base_iomem);
 293                 release_mem_region(base, 2);
 294         }
 295         return -ENODEV;
 296 }
 297
 298 static int __devexit elektor_remove(struct device *dev, unsigned int id)
 299 {
 300         i2c_del_adapter(&pcf_isa_ops);
 301
 302         if (irq > 0) {
 303                 disable_irq(irq);
 304                 free_irq(irq, NULL);
 305         }
 306
 307         if (!mmapped) {
 308                 ioport_unmap(base_iomem);
 309                 release_region(base, 2);
 310         } else {
 311                 iounmap(base_iomem);
 312                 release_mem_region(base, 2);
 313         }
 314
 315         return 0;
 316 }
 317
 318 static struct isa_driver i2c_elektor_driver = {
 319         .match          = elektor_match,
 320         .probe          = elektor_probe,
 321         .remove         = __devexit_p(elektor_remove),
 322         .driver = {
 323                 .owner  = THIS_MODULE,
 324                 .name   = "i2c-elektor",
 325         },
 326 };
 327
 328 static int __init i2c_pcfisa_init(void)
 329 {
 330         return isa_register_driver(&i2c_elektor_driver, 1);
 331 }
 332
 333 static void __exit i2c_pcfisa_exit(void)
 334 {
 335         isa_unregister_driver(&i2c_elektor_driver);
 336 }
 337
 338 MODULE_AUTHOR("Hans Berglund <hb@spacetec.no>");
 339 MODULE_DESCRIPTION("I2C-Bus adapter routines for PCF8584 ISA bus adapter");
 340 MODULE_LICENSE("GPL");
 341
 342 module_param(base, int, 0);
 343 module_param(irq, int, 0);
 344 module_param(clock, int, 0);
 345 module_param(own, int, 0);
 346 module_param(mmapped, int, 0);
 347
 348 module_init(i2c_pcfisa_init);
 349 module_exit(i2c_pcfisa_exit);