Merge branch 'master' of git://oak/home/sfr/kernels/iseries/work
[linux-2.6] / 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         .timeout    = 100,
200 };
201
202 static struct i2c_adapter pcf_isa_ops = {
203         .owner          = THIS_MODULE,
204         .class          = I2C_CLASS_HWMON,
205         .id             = I2C_HW_P_ELEK,
206         .algo_data      = &pcf_isa_data,
207         .name           = "i2c-elektor",
208 };
209
210 static int __init i2c_pcfisa_init(void)
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                                 pr_debug("%s: found cy82c693, config "
226                                          "register 0x47 = 0x%02x\n",
227                                          pcf_isa_ops.name, 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                                         pr_info("%s: found API UP2000 like "
248                                                 "board, will probe PCF8584 "
249                                                 "later\n", pcf_isa_ops.name);
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                 printk(KERN_ERR "%s: incorrect base address (%#x) specified "
260                        "for mmapped I/O\n", pcf_isa_ops.name, base);
261                 return -ENODEV;
262         }
263
264         if (base == 0) {
265                 base = DEFAULT_BASE;
266         }
267
268         init_waitqueue_head(&pcf_wait);
269         if (pcf_isa_init())
270                 return -ENODEV;
271         if (i2c_pcf_add_bus(&pcf_isa_ops) < 0)
272                 goto fail;
273
274         dev_info(&pcf_isa_ops.dev, "found device at %#x\n", base);
275
276         return 0;
277
278  fail:
279         if (irq > 0) {
280                 disable_irq(irq);
281                 free_irq(irq, NULL);
282         }
283
284         if (!mmapped) {
285                 ioport_unmap(base_iomem);
286                 release_region(base, 2);
287         } else {
288                 iounmap(base_iomem);
289                 release_mem_region(base, 2);
290         }
291         return -ENODEV;
292 }
293
294 static void i2c_pcfisa_exit(void)
295 {
296         i2c_pcf_del_bus(&pcf_isa_ops);
297
298         if (irq > 0) {
299                 disable_irq(irq);
300                 free_irq(irq, NULL);
301         }
302
303         if (!mmapped) {
304                 ioport_unmap(base_iomem);
305                 release_region(base, 2);
306         } else {
307                 iounmap(base_iomem);
308                 release_mem_region(base, 2);
309         }
310 }
311
312 MODULE_AUTHOR("Hans Berglund <hb@spacetec.no>");
313 MODULE_DESCRIPTION("I2C-Bus adapter routines for PCF8584 ISA bus adapter");
314 MODULE_LICENSE("GPL");
315
316 module_param(base, int, 0);
317 module_param(irq, int, 0);
318 module_param(clock, int, 0);
319 module_param(own, int, 0);
320 module_param(mmapped, int, 0);
321
322 module_init(i2c_pcfisa_init);
323 module_exit(i2c_pcfisa_exit);