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) { 108 DEFINE_WAIT(wait); 109 int timeout = 2; 110 unsigned long flags; 111 112 if (irq > 0) { 113 spin_lock_irqsave(&lock, flags); 114 if (pcf_pending == 0) { 115 spin_unlock_irqrestore(&lock, flags); 116 prepare_to_wait(&pcf_wait, &wait, TASK_INTERRUPTIBLE); 117 if (schedule_timeout(timeout*HZ)) { 118 spin_lock_irqsave(&lock, flags); 119 if (pcf_pending == 1) { 120 pcf_pending = 0; 121 } 122 spin_unlock_irqrestore(&lock, flags); 123 } 124 finish_wait(&pcf_wait, &wait); 125 } else { 126 pcf_pending = 0; 127 spin_unlock_irqrestore(&lock, flags); 128 } 129 } else { 130 udelay(100); 131 } 132 } 133 134 135 static irqreturn_t pcf_isa_handler(int this_irq, void *dev_id) { 136 spin_lock(&lock); 137 pcf_pending = 1; 138 spin_unlock(&lock); 139 wake_up_interruptible(&pcf_wait); 140 return IRQ_HANDLED; 141 } 142 143 144 static int pcf_isa_init(void) 145 { 146 spin_lock_init(&lock); 147 if (!mmapped) { 148 if (!request_region(base, 2, pcf_isa_ops.name)) { 149 printk(KERN_ERR "%s: requested I/O region (%#x:2) is " 150 "in use\n", pcf_isa_ops.name, base); 151 return -ENODEV; 152 } 153 base_iomem = ioport_map(base, 2); 154 if (!base_iomem) { 155 printk(KERN_ERR "%s: remap of I/O region %#x failed\n", 156 pcf_isa_ops.name, base); 157 release_region(base, 2); 158 return -ENODEV; 159 } 160 } else { 161 if (!request_mem_region(base, 2, pcf_isa_ops.name)) { 162 printk(KERN_ERR "%s: requested memory region (%#x:2) " 163 "is in use\n", pcf_isa_ops.name, base); 164 return -ENODEV; 165 } 166 base_iomem = ioremap(base, 2); 167 if (base_iomem == NULL) { 168 printk(KERN_ERR "%s: remap of memory region %#x " 169 "failed\n", pcf_isa_ops.name, base); 170 release_mem_region(base, 2); 171 return -ENODEV; 172 } 173 } 174 pr_debug("%s: registers %#x remapped to %p\n", pcf_isa_ops.name, base, 175 base_iomem); 176 177 if (irq > 0) { 178 if (request_irq(irq, pcf_isa_handler, 0, pcf_isa_ops.name, 179 NULL) < 0) { 180 printk(KERN_ERR "%s: Request irq%d failed\n", 181 pcf_isa_ops.name, irq); 182 irq = 0; 183 } else 184 enable_irq(irq); 185 } 186 return 0; 187 } 188 189 /* ------------------------------------------------------------------------ 190 * Encapsulate the above functions in the correct operations structure. 191 * This is only done when more than one hardware adapter is supported. 192 */ 193 static struct i2c_algo_pcf_data pcf_isa_data = { 194 .setpcf = pcf_isa_setbyte, 195 .getpcf = pcf_isa_getbyte, 196 .getown = pcf_isa_getown, 197 .getclock = pcf_isa_getclock, 198 .waitforpin = pcf_isa_waitforpin, 199 .udelay = 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 __devinit elektor_match(struct device *dev, unsigned int id) 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 dev_dbg(dev, "found cy82c693, config " 227 "register 0x47 = 0x%02x\n", 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 dev_info(dev, "found API UP2000 like " 248 "board, will probe PCF8584 " 249 "later\n"); 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 dev_err(dev, "incorrect base address (%#x) specified " 260 "for mmapped I/O\n", base); 261 return 0; 262 } 263 264 if (base == 0) { 265 base = DEFAULT_BASE; 266 } 267 return 1; 268 } 269 270 static int __devinit elektor_probe(struct device *dev, unsigned int id) 271 { 272 init_waitqueue_head(&pcf_wait); 273 if (pcf_isa_init()) 274 return -ENODEV; 275 pcf_isa_ops.dev.parent = dev; 276 if (i2c_pcf_add_bus(&pcf_isa_ops) < 0) 277 goto fail; 278 279 dev_info(dev, "found device at %#x\n", base); 280 281 return 0; 282 283 fail: 284 if (irq > 0) { 285 disable_irq(irq); 286 free_irq(irq, NULL); 287 } 288 289 if (!mmapped) { 290 ioport_unmap(base_iomem); 291 release_region(base, 2); 292 } else { 293 iounmap(base_iomem); 294 release_mem_region(base, 2); 295 } 296 return -ENODEV; 297 } 298 299 static int __devexit elektor_remove(struct device *dev, unsigned int id) 300 { 301 i2c_del_adapter(&pcf_isa_ops); 302 303 if (irq > 0) { 304 disable_irq(irq); 305 free_irq(irq, NULL); 306 } 307 308 if (!mmapped) { 309 ioport_unmap(base_iomem); 310 release_region(base, 2); 311 } else { 312 iounmap(base_iomem); 313 release_mem_region(base, 2); 314 } 315 316 return 0; 317 } 318 319 static struct isa_driver i2c_elektor_driver = { 320 .match = elektor_match, 321 .probe = elektor_probe, 322 .remove = __devexit_p(elektor_remove), 323 .driver = { 324 .owner = THIS_MODULE, 325 .name = "i2c-elektor", 326 }, 327 }; 328 329 static int __init i2c_pcfisa_init(void) 330 { 331 return isa_register_driver(&i2c_elektor_driver, 1); 332 } 333 334 static void __exit i2c_pcfisa_exit(void) 335 { 336 isa_unregister_driver(&i2c_elektor_driver); 337 } 338 339 MODULE_AUTHOR("Hans Berglund <hb@spacetec.no>"); 340 MODULE_DESCRIPTION("I2C-Bus adapter routines for PCF8584 ISA bus adapter"); 341 MODULE_LICENSE("GPL"); 342 343 module_param(base, int, 0); 344 module_param(irq, int, 0); 345 module_param(clock, int, 0); 346 module_param(own, int, 0); 347 module_param(mmapped, int, 0); 348 349 module_init(i2c_pcfisa_init); 350 module_exit(i2c_pcfisa_exit); 351