1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
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
49static int base;
50static u8 __iomem *base_iomem;
51
52static int irq;
53static int clock = 0x1c;
54static int own = 0x55;
55static int mmapped;
56
57
58
59
60
61
62static wait_queue_head_t pcf_wait;
63static int pcf_pending;
64static spinlock_t lock;
65
66static struct i2c_adapter pcf_isa_ops;
67
68
69
70static void pcf_isa_setbyte(void *data, int ctl, int val)
71{
72 u8 __iomem *address = ctl ? (base_iomem + 1) : base_iomem;
73
74
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
83 iowrite8(val, address);
84#endif
85}
86
87static 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
96static int pcf_isa_getown(void *data)
97{
98 return (own);
99}
100
101
102static int pcf_isa_getclock(void *data)
103{
104 return (clock);
105}
106
107static 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
136static 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
145static 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
192
193
194static 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
202static struct i2c_adapter pcf_isa_ops = {
203 .owner = THIS_MODULE,
204 .class = I2C_CLASS_HWMON | I2C_CLASS_SPD,
205 .algo_data = &pcf_isa_data,
206 .name = "i2c-elektor",
207};
208
209static int __devinit elektor_match(struct device *dev, unsigned int id)
210{
211#ifdef __alpha__
212
213
214 if (base == 0) {
215 struct pci_dev *cy693_dev;
216
217 cy693_dev = pci_get_device(PCI_VENDOR_ID_CONTAQ,
218 PCI_DEVICE_ID_CONTAQ_82C693, NULL);
219 if (cy693_dev) {
220 unsigned char config;
221
222 if (!pci_read_config_byte(cy693_dev, 0x47, &config)) {
223
224 dev_dbg(dev, "found cy82c693, config "
225 "register 0x47 = 0x%02x\n", config);
226
227
228
229
230
231
232
233
234
235
236
237 if ((config & 0x7f) == 0x61) {
238
239 base = 0xe0000;
240 mmapped = 1;
241
242
243
244 clock = I2C_PCF_CLK | I2C_PCF_TRNS90;
245 dev_info(dev, "found API UP2000 like "
246 "board, will probe PCF8584 "
247 "later\n");
248 }
249 }
250 pci_dev_put(cy693_dev);
251 }
252 }
253#endif
254
255
256 if (mmapped && base < 0xc8000) {
257 dev_err(dev, "incorrect base address (%#x) specified "
258 "for mmapped I/O\n", base);
259 return 0;
260 }
261
262 if (base == 0) {
263 base = DEFAULT_BASE;
264 }
265 return 1;
266}
267
268static int __devinit elektor_probe(struct device *dev, unsigned int id)
269{
270 init_waitqueue_head(&pcf_wait);
271 if (pcf_isa_init())
272 return -ENODEV;
273 pcf_isa_ops.dev.parent = dev;
274 if (i2c_pcf_add_bus(&pcf_isa_ops) < 0)
275 goto fail;
276
277 dev_info(dev, "found device at %#x\n", base);
278
279 return 0;
280
281 fail:
282 if (irq > 0) {
283 disable_irq(irq);
284 free_irq(irq, NULL);
285 }
286
287 if (!mmapped) {
288 ioport_unmap(base_iomem);
289 release_region(base, 2);
290 } else {
291 iounmap(base_iomem);
292 release_mem_region(base, 2);
293 }
294 return -ENODEV;
295}
296
297static int __devexit elektor_remove(struct device *dev, unsigned int id)
298{
299 i2c_del_adapter(&pcf_isa_ops);
300
301 if (irq > 0) {
302 disable_irq(irq);
303 free_irq(irq, NULL);
304 }
305
306 if (!mmapped) {
307 ioport_unmap(base_iomem);
308 release_region(base, 2);
309 } else {
310 iounmap(base_iomem);
311 release_mem_region(base, 2);
312 }
313
314 return 0;
315}
316
317static struct isa_driver i2c_elektor_driver = {
318 .match = elektor_match,
319 .probe = elektor_probe,
320 .remove = __devexit_p(elektor_remove),
321 .driver = {
322 .owner = THIS_MODULE,
323 .name = "i2c-elektor",
324 },
325};
326
327static int __init i2c_pcfisa_init(void)
328{
329 return isa_register_driver(&i2c_elektor_driver, 1);
330}
331
332static void __exit i2c_pcfisa_exit(void)
333{
334 isa_unregister_driver(&i2c_elektor_driver);
335}
336
337MODULE_AUTHOR("Hans Berglund <hb@spacetec.no>");
338MODULE_DESCRIPTION("I2C-Bus adapter routines for PCF8584 ISA bus adapter");
339MODULE_LICENSE("GPL");
340
341module_param(base, int, 0);
342module_param(irq, int, 0);
343module_param(clock, int, 0);
344module_param(own, int, 0);
345module_param(mmapped, int, 0);
346
347module_init(i2c_pcfisa_init);
348module_exit(i2c_pcfisa_exit);
349