1 /* $Id: hysdn_init.c,v 1.1.4.1 2001/11/20 14:19:37 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 
13 #include <linux/config.h>
14 #include <linux/module.h>
15 #include <linux/init.h>
16 #include <linux/version.h>
17 #include <linux/poll.h>
18 #include <linux/vmalloc.h>
19 #include <linux/slab.h>
20 #include <linux/pci.h>
21 
22 #include "hysdn_defs.h"
23 
24 static struct pci_device_id hysdn_pci_tbl[] __initdata = {
25 	{PCI_VENDOR_ID_HYPERCOPE, PCI_DEVICE_ID_HYPERCOPE_PLX, PCI_ANY_ID, PCI_SUBDEVICE_ID_HYPERCOPE_METRO},
26 	{PCI_VENDOR_ID_HYPERCOPE, PCI_DEVICE_ID_HYPERCOPE_PLX, PCI_ANY_ID, PCI_SUBDEVICE_ID_HYPERCOPE_CHAMP2},
27 	{PCI_VENDOR_ID_HYPERCOPE, PCI_DEVICE_ID_HYPERCOPE_PLX, PCI_ANY_ID, PCI_SUBDEVICE_ID_HYPERCOPE_ERGO},
28 	{PCI_VENDOR_ID_HYPERCOPE, PCI_DEVICE_ID_HYPERCOPE_PLX, PCI_ANY_ID, PCI_SUBDEVICE_ID_HYPERCOPE_OLD_ERGO},
29 	{ }				/* Terminating entry */
30 };
31 MODULE_DEVICE_TABLE(pci, hysdn_pci_tbl);
32 MODULE_DESCRIPTION("ISDN4Linux: Driver for HYSDN cards");
33 MODULE_AUTHOR("Werner Cornelius");
34 MODULE_LICENSE("GPL");
35 
36 static char *hysdn_init_revision = "$Revision: 1.1.4.1 $";
37 int cardmax;			/* number of found cards */
38 hysdn_card *card_root = NULL;	/* pointer to first card */
39 
40 /**********************************************/
41 /* table assigning PCI-sub ids to board types */
42 /* the last entry contains all 0              */
43 /**********************************************/
44 static struct {
45 	word subid;		/* PCI sub id */
46 	uchar cardtyp;		/* card type assigned */
47 } pci_subid_map[] = {
48 
49 	{
50 		PCI_SUBDEVICE_ID_HYPERCOPE_METRO, BD_METRO
51 	},
52 	{
53 		PCI_SUBDEVICE_ID_HYPERCOPE_CHAMP2, BD_CHAMP2
54 	},
55 	{
56 		PCI_SUBDEVICE_ID_HYPERCOPE_ERGO, BD_ERGO
57 	},
58 	{
59 		PCI_SUBDEVICE_ID_HYPERCOPE_OLD_ERGO, BD_ERGO
60 	},
61 	{
62 		0, 0
63 	}			/* terminating entry */
64 };
65 
66 
67 /*********************************************************************/
68 /* search_cards searches for available cards in the pci config data. */
69 /* If a card is found, the card structure is allocated and the cards */
70 /* ressources are reserved. cardmax is incremented.                  */
71 /*********************************************************************/
72 static void
search_cards(void)73 search_cards(void)
74 {
75 	struct pci_dev *akt_pcidev = NULL;
76 	hysdn_card *card, *card_last;
77 	int i;
78 
79 	card_root = NULL;
80 	card_last = NULL;
81 	while ((akt_pcidev = pci_find_device(PCI_VENDOR_ID_HYPERCOPE, PCI_DEVICE_ID_HYPERCOPE_PLX,
82 					     akt_pcidev)) != NULL) {
83 		if (pci_enable_device(akt_pcidev))
84 			continue;
85 
86 		if (!(card = kmalloc(sizeof(hysdn_card), GFP_KERNEL))) {
87 			printk(KERN_ERR "HYSDN: unable to alloc device mem \n");
88 			return;
89 		}
90 		memset(card, 0, sizeof(hysdn_card));
91 		card->myid = cardmax;	/* set own id */
92 		card->bus = akt_pcidev->bus->number;
93 		card->devfn = akt_pcidev->devfn;	/* slot + function */
94 		card->subsysid = akt_pcidev->subsystem_device;
95 		card->irq = akt_pcidev->irq;
96 		card->iobase = pci_resource_start(akt_pcidev, PCI_REG_PLX_IO_BASE);
97 		card->plxbase = pci_resource_start(akt_pcidev, PCI_REG_PLX_MEM_BASE);
98 		card->membase = pci_resource_start(akt_pcidev, PCI_REG_MEMORY_BASE);
99 		card->brdtype = BD_NONE;	/* unknown */
100 		card->debug_flags = DEF_DEB_FLAGS;	/* set default debug */
101 		card->faxchans = 0;	/* default no fax channels */
102 		card->bchans = 2;	/* and 2 b-channels */
103 		for (i = 0; pci_subid_map[i].subid; i++)
104 			if (pci_subid_map[i].subid == card->subsysid) {
105 				card->brdtype = pci_subid_map[i].cardtyp;
106 				break;
107 			}
108 		if (card->brdtype != BD_NONE) {
109 			if (ergo_inithardware(card)) {
110 				printk(KERN_WARNING "HYSDN: card at io 0x%04x already in use\n", card->iobase);
111 				kfree(card);
112 				continue;
113 			}
114 		} else {
115 			printk(KERN_WARNING "HYSDN: unknown card id 0x%04x\n", card->subsysid);
116 			kfree(card);	/* release mem */
117 			continue;
118 		}
119 		cardmax++;
120 		card->next = NULL;	/*end of chain */
121 		if (card_last)
122 			card_last->next = card;		/* pointer to next card */
123 		else
124 			card_root = card;
125 		card_last = card;	/* new chain end */
126 	}			/* device found */
127 }				/* search_cards */
128 
129 /************************************************************************************/
130 /* free_resources frees the acquired PCI resources and returns the allocated memory */
131 /************************************************************************************/
132 static void
free_resources(void)133 free_resources(void)
134 {
135 	hysdn_card *card;
136 
137 	while (card_root) {
138 		card = card_root;
139 		if (card->releasehardware)
140 			card->releasehardware(card);	/* free all hardware resources */
141 		card_root = card_root->next;	/* remove card from chain */
142 		kfree(card);	/* return mem */
143 
144 	}			/* while card_root */
145 }				/* free_resources */
146 
147 /**************************************************************************/
148 /* stop_cards disables (hardware resets) all cards and disables interrupt */
149 /**************************************************************************/
150 static void
stop_cards(void)151 stop_cards(void)
152 {
153 	hysdn_card *card;
154 
155 	card = card_root;	/* first in chain */
156 	while (card) {
157 		if (card->stopcard)
158 			card->stopcard(card);
159 		card = card->next;	/* remove card from chain */
160 	}			/* while card */
161 }				/* stop_cards */
162 
163 
164 /****************************************************************************/
165 /* The module startup and shutdown code. Only compiled when used as module. */
166 /* Using the driver as module is always advisable, because the booting      */
167 /* image becomes smaller and the driver code is only loaded when needed.    */
168 /* Additionally newer versions may be activated without rebooting.          */
169 /****************************************************************************/
170 
171 /******************************************************/
172 /* extract revision number from string for log output */
173 /******************************************************/
174 char *
hysdn_getrev(const char * revision)175 hysdn_getrev(const char *revision)
176 {
177 	char *rev;
178 	char *p;
179 
180 	if ((p = strchr(revision, ':'))) {
181 		rev = p + 2;
182 		p = strchr(rev, '$');
183 		*--p = 0;
184 	} else
185 		rev = "???";
186 	return rev;
187 }
188 
189 
190 /****************************************************************************/
191 /* init_module is called once when the module is loaded to do all necessary */
192 /* things like autodetect...                                                */
193 /* If the return value of this function is 0 the init has been successful   */
194 /* and the module is added to the list in /proc/modules, otherwise an error */
195 /* is assumed and the module will not be kept in memory.                    */
196 /****************************************************************************/
197 static int __init
hysdn_init(void)198 hysdn_init(void)
199 {
200 	char tmp[50];
201 
202 	strcpy(tmp, hysdn_init_revision);
203 	printk(KERN_NOTICE "HYSDN: module Rev: %s loaded\n", hysdn_getrev(tmp));
204 	strcpy(tmp, hysdn_net_revision);
205 	printk(KERN_NOTICE "HYSDN: network interface Rev: %s \n", hysdn_getrev(tmp));
206 	if (!pci_present()) {
207 		printk(KERN_ERR "HYSDN: no PCI bus present, module not loaded\n");
208 		return (-1);
209 	}
210 	search_cards();
211 	printk(KERN_INFO "HYSDN: %d card(s) found.\n", cardmax);
212 
213 	if (hysdn_procconf_init()) {
214 		free_resources();	/* proc file_sys not created */
215 		return (-1);
216 	}
217 #ifdef CONFIG_HYSDN_CAPI
218 	if(cardmax > 0) {
219 		if(hycapi_init()) {
220 			printk(KERN_ERR "HYCAPI: init failed\n");
221 			return(-1);
222 		}
223 	}
224 #endif /* CONFIG_HYSDN_CAPI */
225 	return (0);		/* no error */
226 }				/* init_module */
227 
228 
229 /***********************************************************************/
230 /* cleanup_module is called when the module is released by the kernel. */
231 /* The routine is only called if init_module has been successful and   */
232 /* the module counter has a value of 0. Otherwise this function will   */
233 /* not be called. This function must release all resources still allo- */
234 /* cated as after the return from this function the module code will   */
235 /* be removed from memory.                                             */
236 /***********************************************************************/
237 static void __exit
hysdn_exit(void)238 hysdn_exit(void)
239 {
240 #ifdef CONFIG_HYSDN_CAPI
241 	hysdn_card *card;
242 #endif /* CONFIG_HYSDN_CAPI */
243 	stop_cards();
244 #ifdef CONFIG_HYSDN_CAPI
245 	card = card_root;	/* first in chain */
246 	while (card) {
247 		hycapi_capi_release(card);
248 		card = card->next;	/* remove card from chain */
249 	}			/* while card */
250 	hycapi_cleanup();
251 #endif /* CONFIG_HYSDN_CAPI */
252 	hysdn_procconf_release();
253 	free_resources();
254 	printk(KERN_NOTICE "HYSDN: module unloaded\n");
255 }				/* cleanup_module */
256 
257 module_init(hysdn_init);
258 module_exit(hysdn_exit);
259