This source file includes following definitions.
- pcf_isa_setbyte
- pcf_isa_getbyte
- pcf_isa_getown
- pcf_isa_getclock
- pcf_isa_waitforpin
- pcf_isa_handler
- pcf_isa_init
- elektor_match
- elektor_probe
- elektor_remove
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 #include <linux/kernel.h>
18 #include <linux/ioport.h>
19 #include <linux/module.h>
20 #include <linux/delay.h>
21 #include <linux/init.h>
22 #include <linux/interrupt.h>
23 #include <linux/pci.h>
24 #include <linux/wait.h>
25
26 #include <linux/isa.h>
27 #include <linux/i2c.h>
28 #include <linux/i2c-algo-pcf.h>
29 #include <linux/io.h>
30
31 #include <asm/irq.h>
32
33 #include "../algos/i2c-algo-pcf.h"
34
35 #define DEFAULT_BASE 0x330
36
37 static int base;
38 static u8 __iomem *base_iomem;
39
40 static int irq;
41 static int clock = 0x1c;
42 static int own = 0x55;
43 static int mmapped;
44
45
46
47
48
49
50 static wait_queue_head_t pcf_wait;
51 static int pcf_pending;
52 static spinlock_t lock;
53
54 static struct i2c_adapter pcf_isa_ops;
55
56
57
58 static void pcf_isa_setbyte(void *data, int ctl, int val)
59 {
60 u8 __iomem *address = ctl ? (base_iomem + 1) : base_iomem;
61
62
63 if (ctl && irq && (val & I2C_PCF_ESO)) {
64 val |= I2C_PCF_ENI;
65 }
66
67 pr_debug("%s: Write %p 0x%02X\n", pcf_isa_ops.name, address, val);
68 iowrite8(val, address);
69 #ifdef __alpha__
70
71 iowrite8(val, address);
72 #endif
73 }
74
75 static int pcf_isa_getbyte(void *data, int ctl)
76 {
77 u8 __iomem *address = ctl ? (base_iomem + 1) : base_iomem;
78 int val = ioread8(address);
79
80 pr_debug("%s: Read %p 0x%02X\n", pcf_isa_ops.name, address, val);
81 return (val);
82 }
83
84 static int pcf_isa_getown(void *data)
85 {
86 return (own);
87 }
88
89
90 static int pcf_isa_getclock(void *data)
91 {
92 return (clock);
93 }
94
95 static void pcf_isa_waitforpin(void *data)
96 {
97 DEFINE_WAIT(wait);
98 int timeout = 2;
99 unsigned long flags;
100
101 if (irq > 0) {
102 spin_lock_irqsave(&lock, flags);
103 if (pcf_pending == 0) {
104 spin_unlock_irqrestore(&lock, flags);
105 prepare_to_wait(&pcf_wait, &wait, TASK_INTERRUPTIBLE);
106 if (schedule_timeout(timeout*HZ)) {
107 spin_lock_irqsave(&lock, flags);
108 if (pcf_pending == 1) {
109 pcf_pending = 0;
110 }
111 spin_unlock_irqrestore(&lock, flags);
112 }
113 finish_wait(&pcf_wait, &wait);
114 } else {
115 pcf_pending = 0;
116 spin_unlock_irqrestore(&lock, flags);
117 }
118 } else {
119 udelay(100);
120 }
121 }
122
123
124 static irqreturn_t pcf_isa_handler(int this_irq, void *dev_id) {
125 spin_lock(&lock);
126 pcf_pending = 1;
127 spin_unlock(&lock);
128 wake_up_interruptible(&pcf_wait);
129 return IRQ_HANDLED;
130 }
131
132
133 static int pcf_isa_init(void)
134 {
135 spin_lock_init(&lock);
136 if (!mmapped) {
137 if (!request_region(base, 2, pcf_isa_ops.name)) {
138 printk(KERN_ERR "%s: requested I/O region (%#x:2) is "
139 "in use\n", pcf_isa_ops.name, base);
140 return -ENODEV;
141 }
142 base_iomem = ioport_map(base, 2);
143 if (!base_iomem) {
144 printk(KERN_ERR "%s: remap of I/O region %#x failed\n",
145 pcf_isa_ops.name, base);
146 release_region(base, 2);
147 return -ENODEV;
148 }
149 } else {
150 if (!request_mem_region(base, 2, pcf_isa_ops.name)) {
151 printk(KERN_ERR "%s: requested memory region (%#x:2) "
152 "is in use\n", pcf_isa_ops.name, base);
153 return -ENODEV;
154 }
155 base_iomem = ioremap(base, 2);
156 if (base_iomem == NULL) {
157 printk(KERN_ERR "%s: remap of memory region %#x "
158 "failed\n", pcf_isa_ops.name, base);
159 release_mem_region(base, 2);
160 return -ENODEV;
161 }
162 }
163 pr_debug("%s: registers %#x remapped to %p\n", pcf_isa_ops.name, base,
164 base_iomem);
165
166 if (irq > 0) {
167 if (request_irq(irq, pcf_isa_handler, 0, pcf_isa_ops.name,
168 NULL) < 0) {
169 printk(KERN_ERR "%s: Request irq%d failed\n",
170 pcf_isa_ops.name, irq);
171 irq = 0;
172 } else
173 enable_irq(irq);
174 }
175 return 0;
176 }
177
178
179
180
181
182 static struct i2c_algo_pcf_data pcf_isa_data = {
183 .setpcf = pcf_isa_setbyte,
184 .getpcf = pcf_isa_getbyte,
185 .getown = pcf_isa_getown,
186 .getclock = pcf_isa_getclock,
187 .waitforpin = pcf_isa_waitforpin,
188 };
189
190 static struct i2c_adapter pcf_isa_ops = {
191 .owner = THIS_MODULE,
192 .class = I2C_CLASS_HWMON | I2C_CLASS_SPD,
193 .algo_data = &pcf_isa_data,
194 .name = "i2c-elektor",
195 };
196
197 static int elektor_match(struct device *dev, unsigned int id)
198 {
199 #ifdef __alpha__
200
201
202 if (base == 0) {
203 struct pci_dev *cy693_dev;
204
205 cy693_dev = pci_get_device(PCI_VENDOR_ID_CONTAQ,
206 PCI_DEVICE_ID_CONTAQ_82C693, NULL);
207 if (cy693_dev) {
208 unsigned char config;
209
210 if (!pci_read_config_byte(cy693_dev, 0x47, &config)) {
211
212 dev_dbg(dev, "found cy82c693, config "
213 "register 0x47 = 0x%02x\n", config);
214
215
216
217
218
219
220
221
222
223
224
225 if ((config & 0x7f) == 0x61) {
226
227 base = 0xe0000;
228 mmapped = 1;
229
230
231
232 clock = I2C_PCF_CLK | I2C_PCF_TRNS90;
233 dev_info(dev, "found API UP2000 like "
234 "board, will probe PCF8584 "
235 "later\n");
236 }
237 }
238 pci_dev_put(cy693_dev);
239 }
240 }
241 #endif
242
243
244 if (mmapped && base < 0xc8000) {
245 dev_err(dev, "incorrect base address (%#x) specified "
246 "for mmapped I/O\n", base);
247 return 0;
248 }
249
250 if (base == 0) {
251 base = DEFAULT_BASE;
252 }
253 return 1;
254 }
255
256 static int elektor_probe(struct device *dev, unsigned int id)
257 {
258 init_waitqueue_head(&pcf_wait);
259 if (pcf_isa_init())
260 return -ENODEV;
261 pcf_isa_ops.dev.parent = dev;
262 if (i2c_pcf_add_bus(&pcf_isa_ops) < 0)
263 goto fail;
264
265 dev_info(dev, "found device at %#x\n", base);
266
267 return 0;
268
269 fail:
270 if (irq > 0) {
271 disable_irq(irq);
272 free_irq(irq, NULL);
273 }
274
275 if (!mmapped) {
276 ioport_unmap(base_iomem);
277 release_region(base, 2);
278 } else {
279 iounmap(base_iomem);
280 release_mem_region(base, 2);
281 }
282 return -ENODEV;
283 }
284
285 static int elektor_remove(struct device *dev, unsigned int id)
286 {
287 i2c_del_adapter(&pcf_isa_ops);
288
289 if (irq > 0) {
290 disable_irq(irq);
291 free_irq(irq, NULL);
292 }
293
294 if (!mmapped) {
295 ioport_unmap(base_iomem);
296 release_region(base, 2);
297 } else {
298 iounmap(base_iomem);
299 release_mem_region(base, 2);
300 }
301
302 return 0;
303 }
304
305 static struct isa_driver i2c_elektor_driver = {
306 .match = elektor_match,
307 .probe = elektor_probe,
308 .remove = elektor_remove,
309 .driver = {
310 .owner = THIS_MODULE,
311 .name = "i2c-elektor",
312 },
313 };
314
315 MODULE_AUTHOR("Hans Berglund <hb@spacetec.no>");
316 MODULE_DESCRIPTION("I2C-Bus adapter routines for PCF8584 ISA bus adapter");
317 MODULE_LICENSE("GPL");
318
319 module_param_hw(base, int, ioport_or_iomem, 0);
320 module_param_hw(irq, int, irq, 0);
321 module_param(clock, int, 0);
322 module_param(own, int, 0);
323 module_param_hw(mmapped, int, other, 0);
324 module_isa_driver(i2c_elektor_driver, 1);