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); 325