drivers/i2c/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/version.h>
  34 #include <linux/init.h>
  35 #include <linux/pci.h>
  36 #include <asm/irq.h>
  37 #include <asm/io.h>
  38
  39 #include <linux/i2c.h>
  40 #include <linux/i2c-algo-pcf.h>
  41 #include <linux/i2c-elektor.h>
  42 #include "i2c-pcf8584.h"
  43
  44 #define DEFAULT_BASE 0x330
  45
  46 static int base   = 0;
  47 static int irq    = 0;
  48 static int clock  = 0x1c;
  49 static int own    = 0x55;
  50 static int mmapped = 0;
  51 static int i2c_debug = 0;
  52
  53 /* vdovikin: removed static struct i2c_pcf_isa gpi; code -
  54   this module in real supports only one device, due to missing arguments
  55   in some functions, called from the algo-pcf module. Sometimes it's
  56   need to be rewriten - but for now just remove this for simpler reading */
  57
  58 #if (LINUX_VERSION_CODE < 0x020301)
  59 static struct wait_queue *pcf_wait = NULL;
  60 #else
  61 static wait_queue_head_t pcf_wait;
  62 #endif
  63 static int pcf_pending;
  64
  65 /* ----- global defines ----------------------------------------------- */
  66 #define DEB(x)  if (i2c_debug>=1) x
  67 #define DEB2(x) if (i2c_debug>=2) x
  68 #define DEB3(x) if (i2c_debug>=3) x
  69 #define DEBE(x) x       /* error messages                               */
  70
  71 /* ----- local functions ---------------------------------------------- */
  72
  73 static void pcf_isa_setbyte(void *data, int ctl, int val)
  74 {
  75         int address = ctl ? (base + 1) : base;
  76
  77         if (ctl && irq) {
  78                 val |= I2C_PCF_ENI;
  79         }
  80
  81         DEB3(printk("i2c-elektor.o: Write 0x%X 0x%02X\n", address, val & 255));
  82
  83         switch (mmapped) {
  84         case 0: /* regular I/O */
  85                 outb(val, address);
  86                 break;
  87         case 2: /* double mapped I/O needed for UP2000 board,
  88                    I don't know why this... */
  89                 writeb(val, address);
  90                 /* fall */
  91         case 1: /* memory mapped I/O */
  92                 writeb(val, address);
  93                 break;
  94         }
  95 }
  96
  97 static int pcf_isa_getbyte(void *data, int ctl)
  98 {
  99         int address = ctl ? (base + 1) : base;
 100         int val = mmapped ? readb(address) : inb(address);
 101
 102         DEB3(printk("i2c-elektor.o: Read 0x%X 0x%02X\n", address, val));
 103
 104         return (val);
 105 }
 106
 107 static int pcf_isa_getown(void *data)
 108 {
 109         return (own);
 110 }
 111
 112
 113 static int pcf_isa_getclock(void *data)
 114 {
 115         return (clock);
 116 }
 117
 118 static void pcf_isa_waitforpin(void) {
 119
 120         int timeout = 2;
 121
 122         if (irq > 0) {
 123                 cli();
 124                 if (pcf_pending == 0) {
 125                         interruptible_sleep_on_timeout(&pcf_wait, timeout*HZ );
 126                 } else
 127                         pcf_pending = 0;
 128                 sti();
 129         } else {
 130                 udelay(100);
 131         }
 132 }
 133
 134
 135 static void pcf_isa_handler(int this_irq, void *dev_id, struct pt_regs *regs) {
 136         pcf_pending = 1;
 137         wake_up_interruptible(&pcf_wait);
 138 }
 139
 140
 141 static int pcf_isa_init(void)
 142 {
 143         if (!mmapped) {
 144                 if (check_region(base, 2) < 0 ) {
 145                         printk("i2c-elektor.o: requested I/O region (0x%X:2) is in use.\n", base);
 146                         return -ENODEV;
 147                 } else {
 148                         request_region(base, 2, "i2c (isa bus adapter)");
 149                 }
 150         }
 151         if (irq > 0) {
 152                 if (request_irq(irq, pcf_isa_handler, 0, "PCF8584", 0) < 0) {
 153                         printk("i2c-elektor.o: Request irq%d failed\n", irq);
 154                         irq = 0;
 155                 } else
 156                         enable_irq(irq);
 157         }
 158         return 0;
 159 }
 160
 161
 162 static void __exit pcf_isa_exit(void)
 163 {
 164         if (irq > 0) {
 165                 disable_irq(irq);
 166                 free_irq(irq, 0);
 167         }
 168         if (!mmapped) {
 169                 release_region(base , 2);
 170         }
 171 }
 172
 173
 174 static int pcf_isa_reg(struct i2c_client *client)
 175 {
 176         return 0;
 177 }
 178
 179
 180 static int pcf_isa_unreg(struct i2c_client *client)
 181 {
 182         return 0;
 183 }
 184
 185 static void pcf_isa_inc_use(struct i2c_adapter *adap)
 186 {
 187 #ifdef MODULE
 188         MOD_INC_USE_COUNT;
 189 #endif
 190 }
 191
 192 static void pcf_isa_dec_use(struct i2c_adapter *adap)
 193 {
 194 #ifdef MODULE
 195         MOD_DEC_USE_COUNT;
 196 #endif
 197 }
 198
 199
 200 /* ------------------------------------------------------------------------
 201  * Encapsulate the above functions in the correct operations structure.
 202  * This is only done when more than one hardware adapter is supported.
 203  */
 204 static struct i2c_algo_pcf_data pcf_isa_data = {
 205         NULL,
 206         pcf_isa_setbyte,
 207         pcf_isa_getbyte,
 208         pcf_isa_getown,
 209         pcf_isa_getclock,
 210         pcf_isa_waitforpin,
 211         10, 10, 100,            /*      waits, timeout */
 212 };
 213
 214 static struct i2c_adapter pcf_isa_ops = {
 215         "PCF8584 ISA adapter",
 216         I2C_HW_P_ELEK,
 217         NULL,
 218         &pcf_isa_data,
 219         pcf_isa_inc_use,
 220         pcf_isa_dec_use,
 221         pcf_isa_reg,
 222         pcf_isa_unreg,
 223 };
 224
 225 int __init i2c_pcfisa_init(void)
 226 {
 227 #ifdef __alpha__
 228         /* check to see we have memory mapped PCF8584 connected to the
 229         Cypress cy82c693 PCI-ISA bridge as on UP2000 board */
 230         if ((base == 0) && pci_present()) {
 231
 232                 struct pci_dev *cy693_dev =
 233                     pci_find_device(PCI_VENDOR_ID_CONTAQ,
 234                                     PCI_DEVICE_ID_CONTAQ_82C693, NULL);
 235
 236                 if (cy693_dev) {
 237                         char config;
 238                         /* yeap, we've found cypress, let's check config */
 239                         if (!pci_read_config_byte(cy693_dev, 0x47, &config)) {
 240
 241                                 DEB3(printk("i2c-elektor.o: found cy82c693, config register 0x47 = 0x%02x.\n", config));
 242
 243                                 /* UP2000 board has this register set to 0xe1,
 244                                    but the most significant bit as seems can be
 245                                    reset during the proper initialisation
 246                                    sequence if guys from API decides to do that
 247                                    (so, we can even enable Tsunami Pchip
 248                                    window for the upper 1 Gb) */
 249
 250                                 /* so just check for ROMCS at 0xe0000,
 251                                    ROMCS enabled for writes
 252                                    and external XD Bus buffer in use. */
 253                                 if ((config & 0x7f) == 0x61) {
 254                                         /* seems to be UP2000 like board */
 255                                         base = 0xe0000;
 256                                         /* I don't know why we need to
 257                                            write twice */
 258                                         mmapped = 2;
 259                                         /* UP2000 drives ISA with
 260                                            8.25 MHz (PCI/4) clock
 261                                            (this can be read from cypress) */
 262                                         clock = I2C_PCF_CLK | I2C_PCF_TRNS90;
 263                                         printk("i2c-elektor.o: found API UP2000 like board, will probe PCF8584 later.\n");
 264                                 }
 265                         }
 266                 }
 267         }
 268 #endif
 269
 270         /* sanity checks for mmapped I/O */
 271         if (mmapped && base < 0xc8000) {
 272                 printk("i2c-elektor.o: incorrect base address (0x%0X) specified for mmapped I/O.\n", base);
 273                 return -ENODEV;
 274         }
 275
 276         printk("i2c-elektor.o: i2c pcf8584-isa adapter module\n");
 277
 278         if (base == 0) {
 279                 base = DEFAULT_BASE;
 280         }
 281
 282 #if (LINUX_VERSION_CODE >= 0x020301)
 283         init_waitqueue_head(&pcf_wait);
 284 #endif
 285         if (pcf_isa_init() == 0) {
 286                 if (i2c_pcf_add_bus(&pcf_isa_ops) < 0)
 287                         return -ENODEV;
 288         } else {
 289                 return -ENODEV;
 290         }
 291
 292         printk("i2c-elektor.o: found device at %#x.\n", base);
 293
 294         return 0;
 295 }
 296
 297
 298 EXPORT_NO_SYMBOLS;
 299
 300 #ifdef MODULE
 301 MODULE_AUTHOR("Hans Berglund <hb@spacetec.no>");
 302 MODULE_DESCRIPTION("I2C-Bus adapter routines for PCF8584 ISA bus adapter");
 303 MODULE_LICENSE("GPL");
 304
 305 MODULE_PARM(base, "i");
 306 MODULE_PARM(irq, "i");
 307 MODULE_PARM(clock, "i");
 308 MODULE_PARM(own, "i");
 309 MODULE_PARM(mmapped, "i");
 310 MODULE_PARM(i2c_debug, "i");
 311
 312 int init_module(void)
 313 {
 314         return i2c_pcfisa_init();
 315 }
 316
 317 void cleanup_module(void)
 318 {
 319         i2c_pcf_del_bus(&pcf_isa_ops);
 320         pcf_isa_exit();
 321 }
 322
 323 #endif