[mirror_ubuntu-bionic-kernel.git] / drivers / i2c / busses / i2c-elektor.c

/* ------------------------------------------------------------------------- */
/* i2c-elektor.c i2c-hw access for PCF8584 style isa bus adaptes             */
/* ------------------------------------------------------------------------- */
/*   Copyright (C) 1995-97 Simon G. Vogl
                   1998-99 Hans Berglund

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.		     */
/* ------------------------------------------------------------------------- */

/* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi> and even
   Frodo Looijaard <frodol@dds.nl> */

/* Partialy rewriten by Oleg I. Vdovikin for mmapped support of
   for Alpha Processor Inc. UP-2000(+) boards */

#include <linux/kernel.h>
#include <linux/ioport.h>
#include <linux/module.h>
#include <linux/delay.h>
#include <linux/slab.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/pci.h>
#include <linux/wait.h>

#include <linux/isa.h>
#include <linux/i2c.h>
#include <linux/i2c-algo-pcf.h>

#include <asm/io.h>
#include <asm/irq.h>

#include "../algos/i2c-algo-pcf.h"

#define DEFAULT_BASE 0x330

static int base;
static u8 __iomem *base_iomem;

static int irq;
static int clock  = 0x1c;
static int own    = 0x55;
static int mmapped;

/* vdovikin: removed static struct i2c_pcf_isa gpi; code -
  this module in real supports only one device, due to missing arguments
  in some functions, called from the algo-pcf module. Sometimes it's
  need to be rewriten - but for now just remove this for simpler reading */

static wait_queue_head_t pcf_wait;
static int pcf_pending;
static spinlock_t lock;

static struct i2c_adapter pcf_isa_ops;

/* ----- local functions ----------------------------------------------	*/

static void pcf_isa_setbyte(void *data, int ctl, int val)
{
	u8 __iomem *address = ctl ? (base_iomem + 1) : base_iomem;

	/* enable irq if any specified for serial operation */
	if (ctl && irq && (val & I2C_PCF_ESO)) {
		val |= I2C_PCF_ENI;
	}

	pr_debug("%s: Write %p 0x%02X\n", pcf_isa_ops.name, address, val);
	iowrite8(val, address);
#ifdef __alpha__
	/* API UP2000 needs some hardware fudging to make the write stick */
	iowrite8(val, address);
#endif
}

static int pcf_isa_getbyte(void *data, int ctl)
{
	u8 __iomem *address = ctl ? (base_iomem + 1) : base_iomem;
	int val = ioread8(address);

	pr_debug("%s: Read %p 0x%02X\n", pcf_isa_ops.name, address, val);
	return (val);
}

static int pcf_isa_getown(void *data)
{
	return (own);
}


static int pcf_isa_getclock(void *data)
{
	return (clock);
}

static void pcf_isa_waitforpin(void) {
	DEFINE_WAIT(wait);
	int timeout = 2;
	unsigned long flags;

	if (irq > 0) {
		spin_lock_irqsave(&lock, flags);
		if (pcf_pending == 0) {
			spin_unlock_irqrestore(&lock, flags);
			prepare_to_wait(&pcf_wait, &wait, TASK_INTERRUPTIBLE);
			if (schedule_timeout(timeout*HZ)) {
				spin_lock_irqsave(&lock, flags);
				if (pcf_pending == 1) {
					pcf_pending = 0;
				}
				spin_unlock_irqrestore(&lock, flags);
			}
			finish_wait(&pcf_wait, &wait);
		} else {
			pcf_pending = 0;
			spin_unlock_irqrestore(&lock, flags);
		}
	} else {
		udelay(100);
	}
}


static irqreturn_t pcf_isa_handler(int this_irq, void *dev_id) {
	spin_lock(&lock);
	pcf_pending = 1;
	spin_unlock(&lock);
	wake_up_interruptible(&pcf_wait);
	return IRQ_HANDLED;
}


static int pcf_isa_init(void)
{
	spin_lock_init(&lock);
	if (!mmapped) {
		if (!request_region(base, 2, pcf_isa_ops.name)) {
			printk(KERN_ERR "%s: requested I/O region (%#x:2) is "
			       "in use\n", pcf_isa_ops.name, base);
			return -ENODEV;
		}
		base_iomem = ioport_map(base, 2);
		if (!base_iomem) {
			printk(KERN_ERR "%s: remap of I/O region %#x failed\n",
			       pcf_isa_ops.name, base);
			release_region(base, 2);
			return -ENODEV;
		}
	} else {
		if (!request_mem_region(base, 2, pcf_isa_ops.name)) {
			printk(KERN_ERR "%s: requested memory region (%#x:2) "
			       "is in use\n", pcf_isa_ops.name, base);
			return -ENODEV;
		}
		base_iomem = ioremap(base, 2);
		if (base_iomem == NULL) {
			printk(KERN_ERR "%s: remap of memory region %#x "
			       "failed\n", pcf_isa_ops.name, base);
			release_mem_region(base, 2);
			return -ENODEV;
		}
	}
	pr_debug("%s: registers %#x remapped to %p\n", pcf_isa_ops.name, base,
		 base_iomem);

	if (irq > 0) {
		if (request_irq(irq, pcf_isa_handler, 0, pcf_isa_ops.name,
				NULL) < 0) {
			printk(KERN_ERR "%s: Request irq%d failed\n",
			       pcf_isa_ops.name, irq);
			irq = 0;
		} else
			enable_irq(irq);
	}
	return 0;
}

/* ------------------------------------------------------------------------
 * Encapsulate the above functions in the correct operations structure.
 * This is only done when more than one hardware adapter is supported.
 */
static struct i2c_algo_pcf_data pcf_isa_data = {
	.setpcf	    = pcf_isa_setbyte,
	.getpcf	    = pcf_isa_getbyte,
	.getown	    = pcf_isa_getown,
	.getclock   = pcf_isa_getclock,
	.waitforpin = pcf_isa_waitforpin,
	.udelay	    = 10,
	.timeout    = 100,
};

static struct i2c_adapter pcf_isa_ops = {
	.owner		= THIS_MODULE,
	.class		= I2C_CLASS_HWMON,
	.id		= I2C_HW_P_ELEK,
	.algo_data	= &pcf_isa_data,
	.name		= "i2c-elektor",
};

static int __devinit elektor_match(struct device *dev, unsigned int id)
{
#ifdef __alpha__
	/* check to see we have memory mapped PCF8584 connected to the
	Cypress cy82c693 PCI-ISA bridge as on UP2000 board */
	if (base == 0) {
		struct pci_dev *cy693_dev;

		cy693_dev = pci_get_device(PCI_VENDOR_ID_CONTAQ,
					   PCI_DEVICE_ID_CONTAQ_82C693, NULL);
		if (cy693_dev) {
			unsigned char config;
			/* yeap, we've found cypress, let's check config */
			if (!pci_read_config_byte(cy693_dev, 0x47, &config)) {

				dev_dbg(dev, "found cy82c693, config "
					"register 0x47 = 0x%02x\n", config);

				/* UP2000 board has this register set to 0xe1,
				   but the most significant bit as seems can be
				   reset during the proper initialisation
				   sequence if guys from API decides to do that
				   (so, we can even enable Tsunami Pchip
				   window for the upper 1 Gb) */

				/* so just check for ROMCS at 0xe0000,
				   ROMCS enabled for writes
				   and external XD Bus buffer in use. */
				if ((config & 0x7f) == 0x61) {
					/* seems to be UP2000 like board */
					base = 0xe0000;
					mmapped = 1;
					/* UP2000 drives ISA with
					   8.25 MHz (PCI/4) clock
					   (this can be read from cypress) */
					clock = I2C_PCF_CLK | I2C_PCF_TRNS90;
					dev_info(dev, "found API UP2000 like "
						 "board, will probe PCF8584 "
						 "later\n");
				}
			}
			pci_dev_put(cy693_dev);
		}
	}
#endif

	/* sanity checks for mmapped I/O */
	if (mmapped && base < 0xc8000) {
		dev_err(dev, "incorrect base address (%#x) specified "
		       "for mmapped I/O\n", base);
		return 0;
	}

	if (base == 0) {
		base = DEFAULT_BASE;
	}
	return 1;
}

static int __devinit elektor_probe(struct device *dev, unsigned int id)
{
	init_waitqueue_head(&pcf_wait);
	if (pcf_isa_init())
		return -ENODEV;
	pcf_isa_ops.dev.parent = dev;
	if (i2c_pcf_add_bus(&pcf_isa_ops) < 0)
		goto fail;

	dev_info(dev, "found device at %#x\n", base);

	return 0;

 fail:
	if (irq > 0) {
		disable_irq(irq);
		free_irq(irq, NULL);
	}

	if (!mmapped) {
		ioport_unmap(base_iomem);
		release_region(base, 2);
	} else {
		iounmap(base_iomem);
		release_mem_region(base, 2);
	}
	return -ENODEV;
}

static int __devexit elektor_remove(struct device *dev, unsigned int id)
{
	i2c_del_adapter(&pcf_isa_ops);

	if (irq > 0) {
		disable_irq(irq);
		free_irq(irq, NULL);
	}

	if (!mmapped) {
		ioport_unmap(base_iomem);
		release_region(base, 2);
	} else {
		iounmap(base_iomem);
		release_mem_region(base, 2);
	}

	return 0;
}

static struct isa_driver i2c_elektor_driver = {
	.match		= elektor_match,
	.probe		= elektor_probe,
	.remove		= __devexit_p(elektor_remove),
	.driver = {
		.owner	= THIS_MODULE,
		.name	= "i2c-elektor",
	},
};

static int __init i2c_pcfisa_init(void)
{
	return isa_register_driver(&i2c_elektor_driver, 1);
}

static void __exit i2c_pcfisa_exit(void)
{
	isa_unregister_driver(&i2c_elektor_driver);
}

MODULE_AUTHOR("Hans Berglund <hb@spacetec.no>");
MODULE_DESCRIPTION("I2C-Bus adapter routines for PCF8584 ISA bus adapter");
MODULE_LICENSE("GPL");

module_param(base, int, 0);
module_param(irq, int, 0);
module_param(clock, int, 0);
module_param(own, int, 0);
module_param(mmapped, int, 0);

module_init(i2c_pcfisa_init);
module_exit(i2c_pcfisa_exit);
Commit	Line	Data
1da177e4 LT	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
96de0e25	22	/* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi> and even
1da177e4 LT	23	Frodo Looijaard <frodol@dds.nl> */
1da177e4 LT	24
fe3d6a99	25	/* Partialy rewriten by Oleg I. Vdovikin for mmapped support of
1da177e4 LT	26	for Alpha Processor Inc. UP-2000(+) boards */
1da177e4 LT	27
1da177e4 LT	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
4a5d3030	38	#include <linux/isa.h>
1da177e4 LT	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
	49	static int base;
3634ff6a ST	50	static u8 __iomem *base_iomem;
3634ff6a ST	51
1da177e4 LT	52	static int irq;
	53	static int clock = 0x1c;
	54	static int own = 0x55;
	55	static int mmapped;
	56
fe3d6a99	57	/* vdovikin: removed static struct i2c_pcf_isa gpi; code -
1da177e4 LT	58	this module in real supports only one device, due to missing arguments
	59	in some functions, called from the algo-pcf module. Sometimes it's
	60	need to be rewriten - but for now just remove this for simpler reading */
	61
	62	static wait_queue_head_t pcf_wait;
	63	static int pcf_pending;
	64	static spinlock_t lock;
	65
fe3d6a99 ST	66	static struct i2c_adapter pcf_isa_ops;
fe3d6a99 ST	67
1da177e4 LT	68	/* ----- local functions ---------------------------------------------- */
	69
	70	static void pcf_isa_setbyte(void *data, int ctl, int val)
	71	{
3634ff6a	72	u8 __iomem *address = ctl ? (base_iomem + 1) : base_iomem;
1da177e4 LT	73
	74	/* enable irq if any specified for serial operation */
	75	if (ctl && irq && (val & I2C_PCF_ESO)) {
	76	val \|= I2C_PCF_ENI;
	77	}
	78
fe3d6a99	79	pr_debug("%s: Write %p 0x%02X\n", pcf_isa_ops.name, address, val);
3634ff6a ST	80	iowrite8(val, address);
	81	#ifdef __alpha__
	82	/* API UP2000 needs some hardware fudging to make the write stick */
	83	iowrite8(val, address);
	84	#endif
1da177e4 LT	85	}
	86
	87	static int pcf_isa_getbyte(void *data, int ctl)
	88	{
3634ff6a ST	89	u8 __iomem *address = ctl ? (base_iomem + 1) : base_iomem;
3634ff6a ST	90	int val = ioread8(address);
1da177e4	91
fe3d6a99	92	pr_debug("%s: Read %p 0x%02X\n", pcf_isa_ops.name, address, val);
1da177e4 LT	93	return (val);
	94	}
	95
	96	static int pcf_isa_getown(void *data)
	97	{
	98	return (own);
	99	}
	100
	101
	102	static int pcf_isa_getclock(void *data)
	103	{
	104	return (clock);
	105	}
	106
	107	static void pcf_isa_waitforpin(void) {
	108	DEFINE_WAIT(wait);
	109	int timeout = 2;
	110	unsigned long flags;
	111
	112	if (irq > 0) {
	113	spin_lock_irqsave(&lock, flags);
	114	if (pcf_pending == 0) {
	115	spin_unlock_irqrestore(&lock, flags);
	116	prepare_to_wait(&pcf_wait, &wait, TASK_INTERRUPTIBLE);
	117	if (schedule_timeout(timeout*HZ)) {
	118	spin_lock_irqsave(&lock, flags);
	119	if (pcf_pending == 1) {
	120	pcf_pending = 0;
	121	}
	122	spin_unlock_irqrestore(&lock, flags);
	123	}
	124	finish_wait(&pcf_wait, &wait);
	125	} else {
	126	pcf_pending = 0;
	127	spin_unlock_irqrestore(&lock, flags);
	128	}
	129	} else {
	130	udelay(100);
	131	}
	132	}
	133
	134
7d12e780	135	static irqreturn_t pcf_isa_handler(int this_irq, void *dev_id) {
1da177e4 LT	136	spin_lock(&lock);
	137	pcf_pending = 1;
	138	spin_unlock(&lock);
	139	wake_up_interruptible(&pcf_wait);
	140	return IRQ_HANDLED;
	141	}
	142
	143
	144	static int pcf_isa_init(void)
	145	{
	146	spin_lock_init(&lock);
	147	if (!mmapped) {
fe3d6a99 ST	148	if (!request_region(base, 2, pcf_isa_ops.name)) {
	149	printk(KERN_ERR "%s: requested I/O region (%#x:2) is "
	150	"in use\n", pcf_isa_ops.name, base);
1da177e4 LT	151	return -ENODEV;
1da177e4 LT	152	}
3634ff6a ST	153	base_iomem = ioport_map(base, 2);
3634ff6a ST	154	if (!base_iomem) {
fe3d6a99 ST	155	printk(KERN_ERR "%s: remap of I/O region %#x failed\n",
fe3d6a99 ST	156	pcf_isa_ops.name, base);
3634ff6a ST	157	release_region(base, 2);
	158	return -ENODEV;
	159	}
	160	} else {
fe3d6a99 ST	161	if (!request_mem_region(base, 2, pcf_isa_ops.name)) {
	162	printk(KERN_ERR "%s: requested memory region (%#x:2) "
	163	"is in use\n", pcf_isa_ops.name, base);
3634ff6a ST	164	return -ENODEV;
	165	}
	166	base_iomem = ioremap(base, 2);
	167	if (base_iomem == NULL) {
fe3d6a99 ST	168	printk(KERN_ERR "%s: remap of memory region %#x "
fe3d6a99 ST	169	"failed\n", pcf_isa_ops.name, base);
3634ff6a ST	170	release_mem_region(base, 2);
	171	return -ENODEV;
	172	}
1da177e4	173	}
fe3d6a99	174	pr_debug("%s: registers %#x remapped to %p\n", pcf_isa_ops.name, base,
3634ff6a ST	175	base_iomem);
3634ff6a ST	176
1da177e4	177	if (irq > 0) {
fe3d6a99 ST	178	if (request_irq(irq, pcf_isa_handler, 0, pcf_isa_ops.name,
	179	NULL) < 0) {
	180	printk(KERN_ERR "%s: Request irq%d failed\n",
	181	pcf_isa_ops.name, irq);
1da177e4 LT	182	irq = 0;
	183	} else
	184	enable_irq(irq);
	185	}
	186	return 0;
	187	}
	188
	189	/* ------------------------------------------------------------------------
	190	* Encapsulate the above functions in the correct operations structure.
	191	* This is only done when more than one hardware adapter is supported.
	192	*/
	193	static struct i2c_algo_pcf_data pcf_isa_data = {
	194	.setpcf = pcf_isa_setbyte,
	195	.getpcf = pcf_isa_getbyte,
	196	.getown = pcf_isa_getown,
	197	.getclock = pcf_isa_getclock,
	198	.waitforpin = pcf_isa_waitforpin,
	199	.udelay = 10,
1da177e4 LT	200	.timeout = 100,
	201	};
	202
	203	static struct i2c_adapter pcf_isa_ops = {
	204	.owner = THIS_MODULE,
	205	.class = I2C_CLASS_HWMON,
	206	.id = I2C_HW_P_ELEK,
	207	.algo_data = &pcf_isa_data,
fe3d6a99	208	.name = "i2c-elektor",
1da177e4 LT	209	};
1da177e4 LT	210
4a5d3030	211	static int __devinit elektor_match(struct device *dev, unsigned int id)
1da177e4 LT	212	{
1da177e4 LT	213	#ifdef __alpha__
fe3d6a99	214	/* check to see we have memory mapped PCF8584 connected to the
1da177e4 LT	215	Cypress cy82c693 PCI-ISA bridge as on UP2000 board */
	216	if (base == 0) {
	217	struct pci_dev *cy693_dev;
fe3d6a99 ST	218
fe3d6a99 ST	219	cy693_dev = pci_get_device(PCI_VENDOR_ID_CONTAQ,
1da177e4 LT	220	PCI_DEVICE_ID_CONTAQ_82C693, NULL);
1da177e4 LT	221	if (cy693_dev) {
3634ff6a	222	unsigned char config;
1da177e4 LT	223	/* yeap, we've found cypress, let's check config */
1da177e4 LT	224	if (!pci_read_config_byte(cy693_dev, 0x47, &config)) {
fe3d6a99	225
4a5d3030 JD	226	dev_dbg(dev, "found cy82c693, config "
4a5d3030 JD	227	"register 0x47 = 0x%02x\n", config);
1da177e4 LT	228
1da177e4 LT	229	/* UP2000 board has this register set to 0xe1,
fe3d6a99	230	but the most significant bit as seems can be
1da177e4	231	reset during the proper initialisation
fe3d6a99 ST	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) */
1da177e4 LT	235
1da177e4 LT	236	/* so just check for ROMCS at 0xe0000,
fe3d6a99	237	ROMCS enabled for writes
1da177e4 LT	238	and external XD Bus buffer in use. */
	239	if ((config & 0x7f) == 0x61) {
	240	/* seems to be UP2000 like board */
	241	base = 0xe0000;
3634ff6a	242	mmapped = 1;
fe3d6a99	243	/* UP2000 drives ISA with
1da177e4 LT	244	8.25 MHz (PCI/4) clock
	245	(this can be read from cypress) */
	246	clock = I2C_PCF_CLK \| I2C_PCF_TRNS90;
4a5d3030 JD	247	dev_info(dev, "found API UP2000 like "
	248	"board, will probe PCF8584 "
	249	"later\n");
1da177e4 LT	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) {
4a5d3030 JD	259	dev_err(dev, "incorrect base address (%#x) specified "
	260	"for mmapped I/O\n", base);
	261	return 0;
1da177e4 LT	262	}
1da177e4 LT	263
1da177e4 LT	264	if (base == 0) {
	265	base = DEFAULT_BASE;
	266	}
4a5d3030 JD	267	return 1;
4a5d3030 JD	268	}
1da177e4	269
4a5d3030 JD	270	static int __devinit elektor_probe(struct device *dev, unsigned int id)
4a5d3030 JD	271	{
1da177e4 LT	272	init_waitqueue_head(&pcf_wait);
	273	if (pcf_isa_init())
	274	return -ENODEV;
4a5d3030	275	pcf_isa_ops.dev.parent = dev;
1da177e4 LT	276	if (i2c_pcf_add_bus(&pcf_isa_ops) < 0)
1da177e4 LT	277	goto fail;
fe3d6a99	278
4a5d3030	279	dev_info(dev, "found device at %#x\n", base);
1da177e4 LT	280
	281	return 0;
	282
	283	fail:
	284	if (irq > 0) {
	285	disable_irq(irq);
	286	free_irq(irq, NULL);
	287	}
	288
3634ff6a ST	289	if (!mmapped) {
3634ff6a ST	290	ioport_unmap(base_iomem);
fe3d6a99	291	release_region(base, 2);
3634ff6a ST	292	} else {
	293	iounmap(base_iomem);
	294	release_mem_region(base, 2);
	295	}
1da177e4 LT	296	return -ENODEV;
	297	}
	298
4a5d3030	299	static int __devexit elektor_remove(struct device *dev, unsigned int id)
1da177e4	300	{
3269711b	301	i2c_del_adapter(&pcf_isa_ops);
1da177e4 LT	302
	303	if (irq > 0) {
	304	disable_irq(irq);
	305	free_irq(irq, NULL);
	306	}
	307
3634ff6a ST	308	if (!mmapped) {
3634ff6a ST	309	ioport_unmap(base_iomem);
fe3d6a99	310	release_region(base, 2);
3634ff6a ST	311	} else {
	312	iounmap(base_iomem);
	313	release_mem_region(base, 2);
	314	}
4a5d3030 JD	315
	316	return 0;
	317	}
	318
	319	static struct isa_driver i2c_elektor_driver = {
	320	.match = elektor_match,
	321	.probe = elektor_probe,
	322	.remove = __devexit_p(elektor_remove),
	323	.driver = {
	324	.owner = THIS_MODULE,
	325	.name = "i2c-elektor",
	326	},
	327	};
	328
	329	static int __init i2c_pcfisa_init(void)
	330	{
	331	return isa_register_driver(&i2c_elektor_driver, 1);
	332	}
	333
	334	static void __exit i2c_pcfisa_exit(void)
	335	{
	336	isa_unregister_driver(&i2c_elektor_driver);
1da177e4 LT	337	}
	338
	339	MODULE_AUTHOR("Hans Berglund <hb@spacetec.no>");
	340	MODULE_DESCRIPTION("I2C-Bus adapter routines for PCF8584 ISA bus adapter");
	341	MODULE_LICENSE("GPL");
	342
	343	module_param(base, int, 0);
	344	module_param(irq, int, 0);
	345	module_param(clock, int, 0);
	346	module_param(own, int, 0);
	347	module_param(mmapped, int, 0);
	348
	349	module_init(i2c_pcfisa_init);
	350	module_exit(i2c_pcfisa_exit);