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
37static int base;
38static u8 __iomem *base_iomem;
39
40static int irq;
41static int clock = 0x1c;
42static int own = 0x55;
43static int mmapped;
44
45
46
47
48
49
50static wait_queue_head_t pcf_wait;
51static int pcf_pending;
52static DEFINE_SPINLOCK(lock);
53
54static struct i2c_adapter pcf_isa_ops;
55
56
57
58static 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
75static 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
84static int pcf_isa_getown(void *data)
85{
86 return (own);
87}
88
89
90static int pcf_isa_getclock(void *data)
91{
92 return (clock);
93}
94
95static 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
124static 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
133static int pcf_isa_init(void)
134{
135 if (!mmapped) {
136 if (!request_region(base, 2, pcf_isa_ops.name)) {
137 printk(KERN_ERR "%s: requested I/O region (%#x:2) is "
138 "in use\n", pcf_isa_ops.name, base);
139 return -ENODEV;
140 }
141 base_iomem = ioport_map(base, 2);
142 if (!base_iomem) {
143 printk(KERN_ERR "%s: remap of I/O region %#x failed\n",
144 pcf_isa_ops.name, base);
145 release_region(base, 2);
146 return -ENODEV;
147 }
148 } else {
149 if (!request_mem_region(base, 2, pcf_isa_ops.name)) {
150 printk(KERN_ERR "%s: requested memory region (%#x:2) "
151 "is in use\n", pcf_isa_ops.name, base);
152 return -ENODEV;
153 }
154 base_iomem = ioremap(base, 2);
155 if (base_iomem == NULL) {
156 printk(KERN_ERR "%s: remap of memory region %#x "
157 "failed\n", pcf_isa_ops.name, base);
158 release_mem_region(base, 2);
159 return -ENODEV;
160 }
161 }
162 pr_debug("%s: registers %#x remapped to %p\n", pcf_isa_ops.name, base,
163 base_iomem);
164
165 if (irq > 0) {
166 if (request_irq(irq, pcf_isa_handler, 0, pcf_isa_ops.name,
167 NULL) < 0) {
168 printk(KERN_ERR "%s: Request irq%d failed\n",
169 pcf_isa_ops.name, irq);
170 irq = 0;
171 } else
172 enable_irq(irq);
173 }
174 return 0;
175}
176
177
178
179
180
181static struct i2c_algo_pcf_data pcf_isa_data = {
182 .setpcf = pcf_isa_setbyte,
183 .getpcf = pcf_isa_getbyte,
184 .getown = pcf_isa_getown,
185 .getclock = pcf_isa_getclock,
186 .waitforpin = pcf_isa_waitforpin,
187};
188
189static struct i2c_adapter pcf_isa_ops = {
190 .owner = THIS_MODULE,
191 .class = I2C_CLASS_HWMON | I2C_CLASS_SPD,
192 .algo_data = &pcf_isa_data,
193 .name = "i2c-elektor",
194};
195
196static int elektor_match(struct device *dev, unsigned int id)
197{
198#ifdef __alpha__
199
200
201 if (base == 0) {
202 struct pci_dev *cy693_dev;
203
204 cy693_dev = pci_get_device(PCI_VENDOR_ID_CONTAQ,
205 PCI_DEVICE_ID_CONTAQ_82C693, NULL);
206 if (cy693_dev) {
207 unsigned char config;
208
209 if (!pci_read_config_byte(cy693_dev, 0x47, &config)) {
210
211 dev_dbg(dev, "found cy82c693, config "
212 "register 0x47 = 0x%02x\n", config);
213
214
215
216
217
218
219
220
221
222
223
224 if ((config & 0x7f) == 0x61) {
225
226 base = 0xe0000;
227 mmapped = 1;
228
229
230
231 clock = I2C_PCF_CLK | I2C_PCF_TRNS90;
232 dev_info(dev, "found API UP2000 like "
233 "board, will probe PCF8584 "
234 "later\n");
235 }
236 }
237 pci_dev_put(cy693_dev);
238 }
239 }
240#endif
241
242
243 if (mmapped && base < 0xc8000) {
244 dev_err(dev, "incorrect base address (%#x) specified "
245 "for mmapped I/O\n", base);
246 return 0;
247 }
248
249 if (base == 0) {
250 base = DEFAULT_BASE;
251 }
252 return 1;
253}
254
255static int elektor_probe(struct device *dev, unsigned int id)
256{
257 init_waitqueue_head(&pcf_wait);
258 if (pcf_isa_init())
259 return -ENODEV;
260 pcf_isa_ops.dev.parent = dev;
261 if (i2c_pcf_add_bus(&pcf_isa_ops) < 0)
262 goto fail;
263
264 dev_info(dev, "found device at %#x\n", base);
265
266 return 0;
267
268 fail:
269 if (irq > 0) {
270 disable_irq(irq);
271 free_irq(irq, NULL);
272 }
273
274 if (!mmapped) {
275 ioport_unmap(base_iomem);
276 release_region(base, 2);
277 } else {
278 iounmap(base_iomem);
279 release_mem_region(base, 2);
280 }
281 return -ENODEV;
282}
283
284static void elektor_remove(struct device *dev, unsigned int id)
285{
286 i2c_del_adapter(&pcf_isa_ops);
287
288 if (irq > 0) {
289 disable_irq(irq);
290 free_irq(irq, NULL);
291 }
292
293 if (!mmapped) {
294 ioport_unmap(base_iomem);
295 release_region(base, 2);
296 } else {
297 iounmap(base_iomem);
298 release_mem_region(base, 2);
299 }
300}
301
302static struct isa_driver i2c_elektor_driver = {
303 .match = elektor_match,
304 .probe = elektor_probe,
305 .remove = elektor_remove,
306 .driver = {
307 .owner = THIS_MODULE,
308 .name = "i2c-elektor",
309 },
310};
311
312MODULE_AUTHOR("Hans Berglund <hb@spacetec.no>");
313MODULE_DESCRIPTION("I2C-Bus adapter routines for PCF8584 ISA bus adapter");
314MODULE_LICENSE("GPL");
315
316module_param_hw(base, int, ioport_or_iomem, 0);
317module_param_hw(irq, int, irq, 0);
318module_param(clock, int, 0);
319module_param(own, int, 0);
320module_param_hw(mmapped, int, other, 0);
321module_isa_driver(i2c_elektor_driver, 1);
322
