[deliverable/linux.git] / drivers / isdn / hysdn / hysdn_init.c

/* $Id: hysdn_init.c,v 1.6.6.6 2001/09/23 22:24:54 kai Exp $
 *
 * Linux driver for HYSDN cards, init functions.
 *
 * Author    Werner Cornelius (werner@titro.de) for Hypercope GmbH
 * Copyright 1999 by Werner Cornelius (werner@titro.de)
 *
 * This software may be used and distributed according to the terms
 * of the GNU General Public License, incorporated herein by reference.
 *
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/poll.h>
#include <linux/vmalloc.h>
#include <linux/slab.h>
#include <linux/pci.h>

#include "hysdn_defs.h"

static struct pci_device_id hysdn_pci_tbl[] = {
	{ PCI_VENDOR_ID_HYPERCOPE, PCI_DEVICE_ID_HYPERCOPE_PLX,
	  PCI_ANY_ID, PCI_SUBDEVICE_ID_HYPERCOPE_METRO, 0, 0, BD_METRO },
	{ PCI_VENDOR_ID_HYPERCOPE, PCI_DEVICE_ID_HYPERCOPE_PLX,
	  PCI_ANY_ID, PCI_SUBDEVICE_ID_HYPERCOPE_CHAMP2, 0, 0, BD_CHAMP2 },
	{ PCI_VENDOR_ID_HYPERCOPE, PCI_DEVICE_ID_HYPERCOPE_PLX,
	  PCI_ANY_ID, PCI_SUBDEVICE_ID_HYPERCOPE_ERGO, 0, 0, BD_ERGO },
	{ PCI_VENDOR_ID_HYPERCOPE, PCI_DEVICE_ID_HYPERCOPE_PLX,
	  PCI_ANY_ID, PCI_SUBDEVICE_ID_HYPERCOPE_OLD_ERGO, 0, 0, BD_ERGO },

	{ }				/* Terminating entry */
};
MODULE_DEVICE_TABLE(pci, hysdn_pci_tbl);
MODULE_DESCRIPTION("ISDN4Linux: Driver for HYSDN cards");
MODULE_AUTHOR("Werner Cornelius");
MODULE_LICENSE("GPL");

static char *hysdn_init_revision = "$Revision: 1.6.6.6 $";
static int cardmax;		/* number of found cards */
hysdn_card *card_root = NULL;	/* pointer to first card */
static hysdn_card *card_last = NULL;	/* pointer to first card */


/****************************************************************************/
/* The module startup and shutdown code. Only compiled when used as module. */
/* Using the driver as module is always advisable, because the booting      */
/* image becomes smaller and the driver code is only loaded when needed.    */
/* Additionally newer versions may be activated without rebooting.          */
/****************************************************************************/

/******************************************************/
/* extract revision number from string for log output */
/******************************************************/
char *
hysdn_getrev(const char *revision)
{
	char *rev;
	char *p;

	if ((p = strchr(revision, ':'))) {
		rev = p + 2;
		p = strchr(rev, '$');
		*--p = 0;
	} else
		rev = "???";
	return rev;
}


/****************************************************************************/
/* init_module is called once when the module is loaded to do all necessary */
/* things like autodetect...                                                */
/* If the return value of this function is 0 the init has been successful   */
/* and the module is added to the list in /proc/modules, otherwise an error */
/* is assumed and the module will not be kept in memory.                    */
/****************************************************************************/

static int __devinit hysdn_pci_init_one(struct pci_dev *akt_pcidev,
					const struct pci_device_id *ent)
{
	hysdn_card *card;
	int rc;

	rc = pci_enable_device(akt_pcidev);
	if (rc)
		return rc;

	if (!(card = kzalloc(sizeof(hysdn_card), GFP_KERNEL))) {
		printk(KERN_ERR "HYSDN: unable to alloc device mem \n");
		rc = -ENOMEM;
		goto err_out;
	}
	card->myid = cardmax;	/* set own id */
	card->bus = akt_pcidev->bus->number;
	card->devfn = akt_pcidev->devfn;	/* slot + function */
	card->subsysid = akt_pcidev->subsystem_device;
	card->irq = akt_pcidev->irq;
	card->iobase = pci_resource_start(akt_pcidev, PCI_REG_PLX_IO_BASE);
	card->plxbase = pci_resource_start(akt_pcidev, PCI_REG_PLX_MEM_BASE);
	card->membase = pci_resource_start(akt_pcidev, PCI_REG_MEMORY_BASE);
	card->brdtype = BD_NONE;	/* unknown */
	card->debug_flags = DEF_DEB_FLAGS;	/* set default debug */
	card->faxchans = 0;	/* default no fax channels */
	card->bchans = 2;	/* and 2 b-channels */
	card->brdtype = ent->driver_data;

	if (ergo_inithardware(card)) {
		printk(KERN_WARNING "HYSDN: card at io 0x%04x already in use\n", card->iobase);
		rc = -EBUSY;
		goto err_out_card;
	}

	cardmax++;
	card->next = NULL;	/*end of chain */
	if (card_last)
		card_last->next = card;		/* pointer to next card */
	else
		card_root = card;
	card_last = card;	/* new chain end */

	pci_set_drvdata(akt_pcidev, card);
	return 0;

err_out_card:
	kfree(card);
err_out:
	pci_disable_device(akt_pcidev);
	return rc;
}

static void __devexit hysdn_pci_remove_one(struct pci_dev *akt_pcidev)
{
	hysdn_card *card = pci_get_drvdata(akt_pcidev);

	pci_set_drvdata(akt_pcidev, NULL);

	if (card->stopcard)
		card->stopcard(card);

#ifdef CONFIG_HYSDN_CAPI
	hycapi_capi_release(card);
#endif

	if (card->releasehardware)
		card->releasehardware(card);   /* free all hardware resources */

	if (card == card_root) {
		card_root = card_root->next;
		if (!card_root)
			card_last = NULL;
	} else {
		hysdn_card *tmp = card_root;
		while (tmp) {
			if (tmp->next == card)
				tmp->next = card->next;
			card_last = tmp;
			tmp = tmp->next;
		}
	}

	kfree(card);
	pci_disable_device(akt_pcidev);
}

static struct pci_driver hysdn_pci_driver = {
	.name		= "hysdn",
	.id_table	= hysdn_pci_tbl,
	.probe		= hysdn_pci_init_one,
	.remove		= __devexit_p(hysdn_pci_remove_one),
};

static int hysdn_have_procfs;

static int __init
hysdn_init(void)
{
	char tmp[50];
	int rc;

	strcpy(tmp, hysdn_init_revision);
	printk(KERN_NOTICE "HYSDN: module Rev: %s loaded\n", hysdn_getrev(tmp));
	strcpy(tmp, hysdn_net_revision);
	printk(KERN_NOTICE "HYSDN: network interface Rev: %s \n", hysdn_getrev(tmp));

	rc = pci_register_driver(&hysdn_pci_driver);
	if (rc)
		return rc;

	printk(KERN_INFO "HYSDN: %d card(s) found.\n", cardmax);

	if (!hysdn_procconf_init())
		hysdn_have_procfs = 1;

#ifdef CONFIG_HYSDN_CAPI
	if(cardmax > 0) {
		if(hycapi_init()) {
			printk(KERN_ERR "HYCAPI: init failed\n");

			if (hysdn_have_procfs)
				hysdn_procconf_release();

			pci_unregister_driver(&hysdn_pci_driver);
			return -ESPIPE;
		}
	}
#endif /* CONFIG_HYSDN_CAPI */

	return 0;		/* no error */
}				/* init_module */


/***********************************************************************/
/* cleanup_module is called when the module is released by the kernel. */
/* The routine is only called if init_module has been successful and   */
/* the module counter has a value of 0. Otherwise this function will   */
/* not be called. This function must release all resources still allo- */
/* cated as after the return from this function the module code will   */
/* be removed from memory.                                             */
/***********************************************************************/
static void __exit
hysdn_exit(void)
{
	if (hysdn_have_procfs)
		hysdn_procconf_release();

	pci_unregister_driver(&hysdn_pci_driver);

#ifdef CONFIG_HYSDN_CAPI
	hycapi_cleanup();
#endif /* CONFIG_HYSDN_CAPI */

	printk(KERN_NOTICE "HYSDN: module unloaded\n");
}				/* cleanup_module */

module_init(hysdn_init);
module_exit(hysdn_exit);
Commit	Line	Data
1da177e4 LT	1	/* $Id: hysdn_init.c,v 1.6.6.6 2001/09/23 22:24:54 kai Exp $
	2	*
	3	* Linux driver for HYSDN cards, init functions.
	4	*
	5	* Author Werner Cornelius (werner@titro.de) for Hypercope GmbH
	6	* Copyright 1999 by Werner Cornelius (werner@titro.de)
	7	*
	8	* This software may be used and distributed according to the terms
	9	* of the GNU General Public License, incorporated herein by reference.
	10	*
	11	*/
	12
1da177e4 LT	13	#include <linux/module.h>
1da177e4 LT	14	#include <linux/init.h>
1da177e4 LT	15	#include <linux/poll.h>
	16	#include <linux/vmalloc.h>
	17	#include <linux/slab.h>
	18	#include <linux/pci.h>
	19
	20	#include "hysdn_defs.h"
	21
	22	static struct pci_device_id hysdn_pci_tbl[] = {
60cc5147 JG	23	{ PCI_VENDOR_ID_HYPERCOPE, PCI_DEVICE_ID_HYPERCOPE_PLX,
	24	PCI_ANY_ID, PCI_SUBDEVICE_ID_HYPERCOPE_METRO, 0, 0, BD_METRO },
	25	{ PCI_VENDOR_ID_HYPERCOPE, PCI_DEVICE_ID_HYPERCOPE_PLX,
	26	PCI_ANY_ID, PCI_SUBDEVICE_ID_HYPERCOPE_CHAMP2, 0, 0, BD_CHAMP2 },
	27	{ PCI_VENDOR_ID_HYPERCOPE, PCI_DEVICE_ID_HYPERCOPE_PLX,
	28	PCI_ANY_ID, PCI_SUBDEVICE_ID_HYPERCOPE_ERGO, 0, 0, BD_ERGO },
	29	{ PCI_VENDOR_ID_HYPERCOPE, PCI_DEVICE_ID_HYPERCOPE_PLX,
	30	PCI_ANY_ID, PCI_SUBDEVICE_ID_HYPERCOPE_OLD_ERGO, 0, 0, BD_ERGO },
	31
1da177e4 LT	32	{ } /* Terminating entry */
	33	};
	34	MODULE_DEVICE_TABLE(pci, hysdn_pci_tbl);
	35	MODULE_DESCRIPTION("ISDN4Linux: Driver for HYSDN cards");
	36	MODULE_AUTHOR("Werner Cornelius");
	37	MODULE_LICENSE("GPL");
	38
	39	static char *hysdn_init_revision = "$Revision: 1.6.6.6 $";
aade0e82	40	static int cardmax; /* number of found cards */
1da177e4	41	hysdn_card card_root = NULL; / pointer to first card */
60cc5147	42	static hysdn_card card_last = NULL; / pointer to first card */
1da177e4 LT	43
	44
	45	/****************************************************************************/
	46	/* The module startup and shutdown code. Only compiled when used as module. */
	47	/* Using the driver as module is always advisable, because the booting */
	48	/* image becomes smaller and the driver code is only loaded when needed. */
	49	/* Additionally newer versions may be activated without rebooting. */
	50	/****************************************************************************/
	51
	52	/******************************************************/
	53	/* extract revision number from string for log output */
	54	/******************************************************/
	55	char *
	56	hysdn_getrev(const char *revision)
	57	{
	58	char *rev;
	59	char *p;
	60
	61	if ((p = strchr(revision, ':'))) {
	62	rev = p + 2;
	63	p = strchr(rev, '$');
	64	*--p = 0;
	65	} else
	66	rev = "???";
	67	return rev;
	68	}
	69
	70
	71	/****************************************************************************/
	72	/* init_module is called once when the module is loaded to do all necessary */
	73	/* things like autodetect... */
	74	/* If the return value of this function is 0 the init has been successful */
	75	/* and the module is added to the list in /proc/modules, otherwise an error */
	76	/* is assumed and the module will not be kept in memory. */
	77	/****************************************************************************/
60cc5147 JG	78
	79	static int __devinit hysdn_pci_init_one(struct pci_dev *akt_pcidev,
	80	const struct pci_device_id *ent)
	81	{
	82	hysdn_card *card;
	83	int rc;
	84
	85	rc = pci_enable_device(akt_pcidev);
	86	if (rc)
	87	return rc;
	88
	89	if (!(card = kzalloc(sizeof(hysdn_card), GFP_KERNEL))) {
	90	printk(KERN_ERR "HYSDN: unable to alloc device mem \n");
	91	rc = -ENOMEM;
	92	goto err_out;
	93	}
	94	card->myid = cardmax; /* set own id */
	95	card->bus = akt_pcidev->bus->number;
	96	card->devfn = akt_pcidev->devfn; /* slot + function */
	97	card->subsysid = akt_pcidev->subsystem_device;
	98	card->irq = akt_pcidev->irq;
	99	card->iobase = pci_resource_start(akt_pcidev, PCI_REG_PLX_IO_BASE);
	100	card->plxbase = pci_resource_start(akt_pcidev, PCI_REG_PLX_MEM_BASE);
	101	card->membase = pci_resource_start(akt_pcidev, PCI_REG_MEMORY_BASE);
	102	card->brdtype = BD_NONE; /* unknown */
	103	card->debug_flags = DEF_DEB_FLAGS; /* set default debug */
	104	card->faxchans = 0; /* default no fax channels */
	105	card->bchans = 2; /* and 2 b-channels */
	106	card->brdtype = ent->driver_data;
	107
	108	if (ergo_inithardware(card)) {
	109	printk(KERN_WARNING "HYSDN: card at io 0x%04x already in use\n", card->iobase);
	110	rc = -EBUSY;
	111	goto err_out_card;
	112	}
	113
	114	cardmax++;
	115	card->next = NULL; /end of chain /
	116	if (card_last)
	117	card_last->next = card; /* pointer to next card */
	118	else
	119	card_root = card;
	120	card_last = card; /* new chain end */
	121
	122	pci_set_drvdata(akt_pcidev, card);
	123	return 0;
	124
	125	err_out_card:
	126	kfree(card);
	127	err_out:
	128	pci_disable_device(akt_pcidev);
	129	return rc;
	130	}
	131
	132	static void __devexit hysdn_pci_remove_one(struct pci_dev *akt_pcidev)
	133	{
	134	hysdn_card *card = pci_get_drvdata(akt_pcidev);
	135
	136	pci_set_drvdata(akt_pcidev, NULL);
	137
	138	if (card->stopcard)
	139	card->stopcard(card);
	140
	141	#ifdef CONFIG_HYSDN_CAPI
142	hycapi_capi_release(card);
143	#endif
144
145	if (card->releasehardware)
146	card->releasehardware(card); /* free all hardware resources */
147
148	if (card == card_root) {
149	card_root = card_root->next;
150	if (!card_root)
151	card_last = NULL;
152	} else {
153	hysdn_card *tmp = card_root;
154	while (tmp) {
155	if (tmp->next == card)
156	tmp->next = card->next;
157	card_last = tmp;
158	tmp = tmp->next;
159	}
160	}
161
162	kfree(card);
163	pci_disable_device(akt_pcidev);
164	}
165
166	static struct pci_driver hysdn_pci_driver = {
167	.name = "hysdn",
168	.id_table = hysdn_pci_tbl,
169	.probe = hysdn_pci_init_one,
170	.remove = __devexit_p(hysdn_pci_remove_one),
171	};
172
173	static int hysdn_have_procfs;
174
1da177e4 LT	175	static int __init
	176	hysdn_init(void)
	177	{
	178	char tmp[50];
60cc5147	179	int rc;
1da177e4 LT	180
	181	strcpy(tmp, hysdn_init_revision);
	182	printk(KERN_NOTICE "HYSDN: module Rev: %s loaded\n", hysdn_getrev(tmp));
	183	strcpy(tmp, hysdn_net_revision);
	184	printk(KERN_NOTICE "HYSDN: network interface Rev: %s \n", hysdn_getrev(tmp));
60cc5147 JG	185
	186	rc = pci_register_driver(&hysdn_pci_driver);
	187	if (rc)
	188	return rc;
	189
1da177e4 LT	190	printk(KERN_INFO "HYSDN: %d card(s) found.\n", cardmax);
1da177e4 LT	191
60cc5147 JG	192	if (!hysdn_procconf_init())
	193	hysdn_have_procfs = 1;
	194
1da177e4 LT	195	#ifdef CONFIG_HYSDN_CAPI
	196	if(cardmax > 0) {
	197	if(hycapi_init()) {
	198	printk(KERN_ERR "HYCAPI: init failed\n");
60cc5147 JG	199
	200	if (hysdn_have_procfs)
	201	hysdn_procconf_release();
	202
	203	pci_unregister_driver(&hysdn_pci_driver);
	204	return -ESPIPE;
1da177e4 LT	205	}
	206	}
	207	#endif /* CONFIG_HYSDN_CAPI */
60cc5147 JG	208
60cc5147 JG	209	return 0; /* no error */
1da177e4 LT	210	} /* init_module */
	211
	212
	213	/***********************************************************************/
	214	/* cleanup_module is called when the module is released by the kernel. */
	215	/* The routine is only called if init_module has been successful and */
	216	/* the module counter has a value of 0. Otherwise this function will */
	217	/* not be called. This function must release all resources still allo- */
	218	/* cated as after the return from this function the module code will */
	219	/* be removed from memory. */
	220	/***********************************************************************/
	221	static void __exit
	222	hysdn_exit(void)
	223	{
60cc5147 JG	224	if (hysdn_have_procfs)
	225	hysdn_procconf_release();
	226
	227	pci_unregister_driver(&hysdn_pci_driver);
	228
1da177e4	229	#ifdef CONFIG_HYSDN_CAPI
1da177e4 LT	230	hycapi_cleanup();
1da177e4 LT	231	#endif /* CONFIG_HYSDN_CAPI */
60cc5147	232
1da177e4 LT	233	printk(KERN_NOTICE "HYSDN: module unloaded\n");
	234	} /* cleanup_module */
	235
	236	module_init(hysdn_init);
	237	module_exit(hysdn_exit);