1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* ------------------------------------------------------------------------- */
3 /* i2c-elektor.c i2c-hw access for PCF8584 style isa bus adaptes             */
4 /* ------------------------------------------------------------------------- */
5 /*   Copyright (C) 1995-97 Simon G. Vogl
6                    1998-99 Hans Berglund
7 
8  */
9 /* ------------------------------------------------------------------------- */
10 
11 /* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi> and even
12    Frodo Looijaard <frodol@dds.nl> */
13 
14 /* Partially rewriten by Oleg I. Vdovikin for mmapped support of
15    for Alpha Processor Inc. UP-2000(+) boards */
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 /* vdovikin: removed static struct i2c_pcf_isa gpi; code -
46   this module in real supports only one device, due to missing arguments
47   in some functions, called from the algo-pcf module. Sometimes it's
48   need to be rewriten - but for now just remove this for simpler reading */
49 
50 static wait_queue_head_t pcf_wait;
51 static int pcf_pending;
52 static DEFINE_SPINLOCK(lock);
53 
54 static struct i2c_adapter pcf_isa_ops;
55 
56 /* ----- local functions ----------------------------------------------	*/
57 
pcf_isa_setbyte(void * data,int ctl,int val)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 	/* enable irq if any specified for serial operation */
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 	/* API UP2000 needs some hardware fudging to make the write stick */
71 	iowrite8(val, address);
72 #endif
73 }
74 
pcf_isa_getbyte(void * data,int ctl)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 
pcf_isa_getown(void * data)84 static int pcf_isa_getown(void *data)
85 {
86 	return (own);
87 }
88 
89 
pcf_isa_getclock(void * data)90 static int pcf_isa_getclock(void *data)
91 {
92 	return (clock);
93 }
94 
pcf_isa_waitforpin(void * data)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 
pcf_isa_handler(int this_irq,void * dev_id)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 
pcf_isa_init(void)133 static 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  * Encapsulate the above functions in the correct operations structure.
179  * This is only done when more than one hardware adapter is supported.
180  */
181 static 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 
189 static 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 
elektor_match(struct device * dev,unsigned int id)196 static int elektor_match(struct device *dev, unsigned int id)
197 {
198 #ifdef __alpha__
199 	/* check to see we have memory mapped PCF8584 connected to the
200 	Cypress cy82c693 PCI-ISA bridge as on UP2000 board */
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 			/* yeap, we've found cypress, let's check config */
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 				/* UP2000 board has this register set to 0xe1,
215 				   but the most significant bit as seems can be
216 				   reset during the proper initialisation
217 				   sequence if guys from API decides to do that
218 				   (so, we can even enable Tsunami Pchip
219 				   window for the upper 1 Gb) */
220 
221 				/* so just check for ROMCS at 0xe0000,
222 				   ROMCS enabled for writes
223 				   and external XD Bus buffer in use. */
224 				if ((config & 0x7f) == 0x61) {
225 					/* seems to be UP2000 like board */
226 					base = 0xe0000;
227 					mmapped = 1;
228 					/* UP2000 drives ISA with
229 					   8.25 MHz (PCI/4) clock
230 					   (this can be read from cypress) */
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 	/* sanity checks for mmapped I/O */
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 
elektor_probe(struct device * dev,unsigned int id)255 static 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 
elektor_remove(struct device * dev,unsigned int id)284 static 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 
302 static 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 
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_hw(base, int, ioport_or_iomem, 0);
317 module_param_hw(irq, int, irq, 0);
318 module_param(clock, int, 0);
319 module_param(own, int, 0);
320 module_param_hw(mmapped, int, other, 0);
321 module_isa_driver(i2c_elektor_driver, 1);
322