This commit was generated by cvs2svn to compensate for changes in r517,
[linux-2.6.git] / drivers / isdn / sc / init.c
1 /*
2  * This software may be used and distributed according to the terms
3  * of the GNU General Public License, incorporated herein by reference.
4  *
5  */
6
7 #include <linux/module.h>
8 #include <linux/init.h>
9 #include <linux/interrupt.h>
10 #include <linux/delay.h>
11 #include "includes.h"
12 #include "hardware.h"
13 #include "card.h"
14
15 MODULE_DESCRIPTION("ISDN4Linux: Driver for Spellcaster card");
16 MODULE_AUTHOR("Spellcaster Telecommunications Inc.");
17 MODULE_LICENSE("GPL");
18 MODULE_PARM( io, "1-" __MODULE_STRING(MAX_CARDS) "i");
19 MODULE_PARM(irq, "1-" __MODULE_STRING(MAX_CARDS) "i");
20 MODULE_PARM(ram, "1-" __MODULE_STRING(MAX_CARDS) "i");
21 MODULE_PARM(do_reset, "i");
22
23 board *sc_adapter[MAX_CARDS];
24 int cinst;
25
26 static char devname[] = "scX";
27 const char version[] = "2.0b1";
28
29 const char *boardname[] = { "DataCommute/BRI", "DataCommute/PRI", "TeleCommute/BRI" };
30
31 /* insmod set parameters */
32 static unsigned int io[] = {0,0,0,0};
33 static unsigned char irq[] = {0,0,0,0};
34 static unsigned long ram[] = {0,0,0,0};
35 static int do_reset = 0;
36
37 static int sup_irq[] = { 11, 10, 9, 5, 12, 14, 7, 3, 4, 6 };
38 #define MAX_IRQS        10
39
40 extern irqreturn_t interrupt_handler(int, void *, struct pt_regs *);
41 extern int sndpkt(int, int, int, struct sk_buff *);
42 extern int command(isdn_ctrl *);
43 extern int indicate_status(int, int, ulong, char*);
44 extern int reset(int);
45
46 int identify_board(unsigned long, unsigned int);
47
48 int irq_supported(int irq_x)
49 {
50         int i;
51         for(i=0 ; i < MAX_IRQS ; i++) {
52                 if(sup_irq[i] == irq_x)
53                         return 1;
54         }
55         return 0;
56 }
57
58 static int __init sc_init(void)
59 {
60         int b = -1;
61         int i, j;
62         int status = -ENODEV;
63
64         unsigned long memsize = 0;
65         unsigned long features = 0;
66         isdn_if *interface;
67         unsigned char channels;
68         unsigned char pgport;
69         unsigned long magic;
70         int model;
71         int last_base = IOBASE_MIN;
72         int probe_exhasted = 0;
73
74 #ifdef MODULE
75         pr_info("SpellCaster ISA ISDN Adapter Driver rev. %s Loaded\n", version);
76 #else
77         pr_info("SpellCaster ISA ISDN Adapter Driver rev. %s\n", version);
78 #endif
79         pr_info("Copyright (C) 1996 SpellCaster Telecommunications Inc.\n");
80
81         while(b++ < MAX_CARDS - 1) {
82                 pr_debug("Probing for adapter #%d\n", b);
83                 /*
84                  * Initialize reusable variables
85                  */
86                 model = -1;
87                 magic = 0;
88                 channels = 0;
89                 pgport = 0;
90
91                 /* 
92                  * See if we should probe for IO base 
93                  */
94                 pr_debug("I/O Base for board %d is 0x%x, %s probe\n", b, io[b],
95                         io[b] == 0 ? "will" : "won't");
96                 if(io[b]) {
97                         /*
98                          * No, I/O Base has been provided
99                          */
100                         for (i = 0 ; i < MAX_IO_REGS - 1 ; i++) {
101                                 if(!request_region(io[b] + i * 0x400, 1, "sc test")) {
102                                         pr_debug("check_region for 0x%x failed\n", io[b] + i * 0x400);
103                                         io[b] = 0;
104                                         break;
105                                 } else
106                                         release_region(io[b] + i * 0x400, 1);
107                         }
108
109                         /*
110                          * Confirm the I/O Address with a test
111                          */
112                         if(io[b] == 0) {
113                                 pr_debug("I/O Address 0x%x is in use.\n");
114                                 continue;
115                         }
116
117                         outb(0x18, io[b] + 0x400 * EXP_PAGE0);
118                         if(inb(io[b] + 0x400 * EXP_PAGE0) != 0x18) {
119                                 pr_debug("I/O Base 0x%x fails test\n");
120                                 continue;
121                         }
122                 }
123                 else {
124                         /*
125                          * Yes, probe for I/O Base
126                          */
127                         if(probe_exhasted) {
128                                 pr_debug("All probe addresses exhasted, skipping\n");
129                                 continue;
130                         }
131                         pr_debug("Probing for I/O...\n");
132                         for (i = last_base ; i <= IOBASE_MAX ; i += IOBASE_OFFSET) {
133                                 int found_io = 1;
134                                 if (i == IOBASE_MAX) {
135                                         probe_exhasted = 1; /* No more addresses to probe */
136                                         pr_debug("End of Probes\n");
137                                 }
138                                 last_base = i + IOBASE_OFFSET;
139                                 pr_debug("  checking 0x%x...", i);
140                                 for ( j = 0 ; j < MAX_IO_REGS - 1 ; j++) {
141                                         if(!request_region(i + j * 0x400, 1, "sc test")) {
142                                                 pr_debug("Failed\n");
143                                                 found_io = 0;
144                                                 break;
145                                         } else
146                                                 release_region(i + j * 0x400, 1);
147                                 }       
148
149                                 if(found_io) {
150                                         io[b] = i;
151                                         outb(0x18, io[b] + 0x400 * EXP_PAGE0);
152                                         if(inb(io[b] + 0x400 * EXP_PAGE0) != 0x18) { 
153                                                 pr_debug("Failed by test\n");
154                                                 continue;
155                                         }
156                                         pr_debug("Passed\n");
157                                         break;
158                                 }
159                         }
160                         if(probe_exhasted) {
161                                 continue;
162                         }
163                 }
164
165                 /*
166                  * See if we should probe for shared RAM
167                  */
168                 if(do_reset) {
169                         pr_debug("Doing a SAFE probe reset\n");
170                         outb(0xFF, io[b] + RESET_OFFSET);
171                         msleep_interruptible(10000);
172                 }
173                 pr_debug("RAM Base for board %d is 0x%x, %s probe\n", b, ram[b],
174                         ram[b] == 0 ? "will" : "won't");
175
176                 if(ram[b]) {
177                         /*
178                          * No, the RAM base has been provided
179                          * Just look for a signature and ID the
180                          * board model
181                          */
182                         if(request_region(ram[b], SRAM_PAGESIZE, "sc test")) {
183                                 pr_debug("request_region for RAM base 0x%x succeeded\n", ram[b]);
184                                 model = identify_board(ram[b], io[b]);
185                                 release_region(ram[b], SRAM_PAGESIZE);
186                         }
187                 }
188                 else {
189                         /*
190                          * Yes, probe for free RAM and look for
191                          * a signature and id the board model
192                          */
193                         for (i = SRAM_MIN ; i < SRAM_MAX ; i += SRAM_PAGESIZE) {
194                                 pr_debug("Checking RAM address 0x%x...\n", i);
195                                 if(request_region(i, SRAM_PAGESIZE, "sc test")) {
196                                         pr_debug("  check_region succeeded\n");
197                                         model = identify_board(i, io[b]);
198                                         release_region(i, SRAM_PAGESIZE);
199                                         if (model >= 0) {
200                                                 pr_debug("  Identified a %s\n",
201                                                         boardname[model]);
202                                                 ram[b] = i;
203                                                 break;
204                                         }
205                                         pr_debug("  Unidentifed or inaccessible\n");
206                                         continue;
207                                 }
208                                 pr_debug("  request failed\n");
209                         }
210                 }
211                 /*
212                  * See if we found free RAM and the board model
213                  */
214                 if(!ram[b] || model < 0) {
215                         /*
216                          * Nope, there was no place in RAM for the
217                          * board, or it couldn't be identified
218                          */
219                          pr_debug("Failed to find an adapter at 0x%x\n", ram[b]);
220                          continue;
221                 }
222
223                 /*
224                  * Set the board's magic number, memory size and page register
225                  */
226                 switch(model) {
227                 case PRI_BOARD:
228                         channels = 23;
229                         magic = 0x20000;
230                         memsize = 0x100000;
231                         features = PRI_FEATURES;
232                         break;
233
234                 case BRI_BOARD:
235                 case POTS_BOARD:
236                         channels = 2;
237                         magic = 0x60000;
238                         memsize = 0x10000;
239                         features = BRI_FEATURES;
240                         break;
241                 }
242                 switch(ram[b] >> 12 & 0x0F) {
243                 case 0x0:
244                         pr_debug("RAM Page register set to EXP_PAGE0\n");
245                         pgport = EXP_PAGE0;
246                         break;
247
248                 case 0x4:
249                         pr_debug("RAM Page register set to EXP_PAGE1\n");
250                         pgport = EXP_PAGE1;
251                         break;
252
253                 case 0x8:
254                         pr_debug("RAM Page register set to EXP_PAGE2\n");
255                         pgport = EXP_PAGE2;
256                         break;
257
258                 case 0xC:
259                         pr_debug("RAM Page register set to EXP_PAGE3\n");
260                         pgport = EXP_PAGE3;
261                         break;
262
263                 default:
264                         pr_debug("RAM base address doesn't fall on 16K boundary\n");
265                         continue;
266                 }
267
268                 pr_debug("current IRQ: %d  b: %d\n",irq[b],b);
269
270                 /*
271                  * Make sure we got an IRQ
272                  */
273                 if(!irq[b]) {
274                         /*
275                          * No interrupt could be used
276                          */
277                         pr_debug("Failed to acquire an IRQ line\n");
278                         continue;
279                 }
280
281                 /*
282                  * Horray! We found a board, Make sure we can register
283                  * it with ISDN4Linux
284                  */
285                 interface = kmalloc(sizeof(isdn_if), GFP_KERNEL);
286                 if (interface == NULL) {
287                         /*
288                          * Oops, can't malloc isdn_if
289                          */
290                         continue;
291                 }
292                 memset(interface, 0, sizeof(isdn_if));
293
294                 interface->owner = THIS_MODULE;
295                 interface->hl_hdrlen = 0;
296                 interface->channels = channels;
297                 interface->maxbufsize = BUFFER_SIZE;
298                 interface->features = features;
299                 interface->writebuf_skb = sndpkt;
300                 interface->writecmd = NULL;
301                 interface->command = command;
302                 strcpy(interface->id, devname);
303                 interface->id[2] = '0' + cinst;
304
305                 /*
306                  * Allocate the board structure
307                  */
308                 sc_adapter[cinst] = kmalloc(sizeof(board), GFP_KERNEL);
309                 if (sc_adapter[cinst] == NULL) {
310                         /*
311                          * Oops, can't alloc memory for the board
312                          */
313                         kfree(interface);
314                         continue;
315                 }
316                 memset(sc_adapter[cinst], 0, sizeof(board));
317                 spin_lock_init(&sc_adapter[cinst]->lock);
318
319                 if(!register_isdn(interface)) {
320                         /*
321                          * Oops, couldn't register for some reason
322                          */
323                         kfree(interface);
324                         kfree(sc_adapter[cinst]);
325                         continue;
326                 }
327
328                 sc_adapter[cinst]->card = interface;
329                 sc_adapter[cinst]->driverId = interface->channels;
330                 strcpy(sc_adapter[cinst]->devicename, interface->id);
331                 sc_adapter[cinst]->nChannels = channels;
332                 sc_adapter[cinst]->ramsize = memsize;
333                 sc_adapter[cinst]->shmem_magic = magic;
334                 sc_adapter[cinst]->shmem_pgport = pgport;
335                 sc_adapter[cinst]->StartOnReset = 1;
336
337                 /*
338                  * Allocate channels status structures
339                  */
340                 sc_adapter[cinst]->channel = kmalloc(sizeof(bchan) * channels, GFP_KERNEL);
341                 if (sc_adapter[cinst]->channel == NULL) {
342                         /*
343                          * Oops, can't alloc memory for the channels
344                          */
345                         indicate_status(cinst, ISDN_STAT_UNLOAD, 0, NULL);      /* Fix me */
346                         kfree(interface);
347                         kfree(sc_adapter[cinst]);
348                         continue;
349                 }
350                 memset(sc_adapter[cinst]->channel, 0, sizeof(bchan) * channels);
351
352                 /*
353                  * Lock down the hardware resources
354                  */
355                 sc_adapter[cinst]->interrupt = irq[b];
356                 if (request_irq(sc_adapter[cinst]->interrupt, interrupt_handler,
357                                 SA_INTERRUPT, interface->id, NULL))
358                 {
359                         kfree(sc_adapter[cinst]->channel);
360                         indicate_status(cinst, ISDN_STAT_UNLOAD, 0, NULL);      /* Fix me */
361                         kfree(interface);
362                         kfree(sc_adapter[cinst]);
363                         continue;
364                         
365                 }
366                 sc_adapter[cinst]->iobase = io[b];
367                 for(i = 0 ; i < MAX_IO_REGS - 1 ; i++) {
368                         sc_adapter[cinst]->ioport[i] = io[b] + i * 0x400;
369                         request_region(sc_adapter[cinst]->ioport[i], 1,
370                                         interface->id);
371                         pr_debug("Requesting I/O Port %#x\n",
372                                 sc_adapter[cinst]->ioport[i]);
373                 }
374                 sc_adapter[cinst]->ioport[IRQ_SELECT] = io[b] + 0x2;
375                 request_region(sc_adapter[cinst]->ioport[IRQ_SELECT], 1,
376                                 interface->id);
377                 pr_debug("Requesting I/O Port %#x\n",
378                                 sc_adapter[cinst]->ioport[IRQ_SELECT]);
379                 sc_adapter[cinst]->rambase = ram[b];
380                 request_region(sc_adapter[cinst]->rambase, SRAM_PAGESIZE,
381                                 interface->id);
382
383                 pr_info("  %s (%d) - %s %d channels IRQ %d, I/O Base 0x%x, RAM Base 0x%lx\n", 
384                         sc_adapter[cinst]->devicename,
385                         sc_adapter[cinst]->driverId,
386                         boardname[model], channels, irq[b], io[b], ram[b]);
387                 
388                 /*
389                  * reset the adapter to put things in motion
390                  */
391                 reset(cinst);
392
393                 cinst++;
394                 status = 0;
395         }
396         if (status) 
397                 pr_info("Failed to find any adapters, driver unloaded\n");
398         return status;
399 }
400
401 static void __exit sc_exit(void)
402 {
403         int i, j;
404
405         for(i = 0 ; i < cinst ; i++) {
406                 pr_debug("Cleaning up after adapter %d\n", i);
407                 /*
408                  * kill the timers
409                  */
410                 del_timer(&(sc_adapter[i]->reset_timer));
411                 del_timer(&(sc_adapter[i]->stat_timer));
412
413                 /*
414                  * Tell I4L we're toast
415                  */
416                 indicate_status(i, ISDN_STAT_STOP, 0, NULL);
417                 indicate_status(i, ISDN_STAT_UNLOAD, 0, NULL);
418
419                 /*
420                  * Release shared RAM
421                  */
422                 release_region(sc_adapter[i]->rambase, SRAM_PAGESIZE);
423
424                 /*
425                  * Release the IRQ
426                  */
427                 FREE_IRQ(sc_adapter[i]->interrupt, NULL);
428
429                 /*
430                  * Reset for a clean start
431                  */
432                 outb(0xFF, sc_adapter[i]->ioport[SFT_RESET]);
433
434                 /*
435                  * Release the I/O Port regions
436                  */
437                 for(j = 0 ; j < MAX_IO_REGS - 1; j++) {
438                         release_region(sc_adapter[i]->ioport[j], 1);
439                         pr_debug("Releasing I/O Port %#x\n",
440                                 sc_adapter[i]->ioport[j]);
441                 }
442                 release_region(sc_adapter[i]->ioport[IRQ_SELECT], 1);
443                 pr_debug("Releasing I/O Port %#x\n",
444                         sc_adapter[i]->ioport[IRQ_SELECT]);
445
446                 /*
447                  * Release any memory we alloced
448                  */
449                 kfree(sc_adapter[i]->channel);
450                 kfree(sc_adapter[i]->card);
451                 kfree(sc_adapter[i]);
452         }
453         pr_info("SpellCaster ISA ISDN Adapter Driver Unloaded.\n");
454 }
455
456 int identify_board(unsigned long rambase, unsigned int iobase) 
457 {
458         unsigned int pgport;
459         unsigned long sig;
460         DualPortMemory *dpm;
461         RspMessage rcvmsg;
462         ReqMessage sndmsg;
463         HWConfig_pl hwci;
464         int x;
465
466         pr_debug("Attempting to identify adapter @ 0x%x io 0x%x\n",
467                 rambase, iobase);
468
469         /*
470          * Enable the base pointer
471          */
472         outb(rambase >> 12, iobase + 0x2c00);
473
474         switch(rambase >> 12 & 0x0F) {
475         case 0x0:
476                 pgport = iobase + PG0_OFFSET;
477                 pr_debug("Page Register offset is 0x%x\n", PG0_OFFSET);
478                 break;
479                 
480         case 0x4:
481                 pgport = iobase + PG1_OFFSET;
482                 pr_debug("Page Register offset is 0x%x\n", PG1_OFFSET);
483                 break;
484
485         case 0x8:
486                 pgport = iobase + PG2_OFFSET;
487                 pr_debug("Page Register offset is 0x%x\n", PG2_OFFSET);
488                 break;
489
490         case 0xC:
491                 pgport = iobase + PG3_OFFSET;
492                 pr_debug("Page Register offset is 0x%x\n", PG3_OFFSET);
493                 break;
494         default:
495                 pr_debug("Invalid rambase 0x%lx\n", rambase);
496                 return -1;
497         }
498
499         /*
500          * Try to identify a PRI card
501          */
502         outb(PRI_BASEPG_VAL, pgport);
503         msleep_interruptible(1000);
504         sig = readl(rambase + SIG_OFFSET);
505         pr_debug("Looking for a signature, got 0x%x\n", sig);
506         if(sig == SIGNATURE)
507                 return PRI_BOARD;
508
509         /*
510          * Try to identify a PRI card
511          */
512         outb(BRI_BASEPG_VAL, pgport);
513         msleep_interruptible(1000);
514         sig = readl(rambase + SIG_OFFSET);
515         pr_debug("Looking for a signature, got 0x%x\n", sig);
516         if(sig == SIGNATURE)
517                 return BRI_BOARD;
518
519         return -1;
520
521         /*
522          * Try to spot a card
523          */
524         sig = readl(rambase + SIG_OFFSET);
525         pr_debug("Looking for a signature, got 0x%x\n", sig);
526         if(sig != SIGNATURE)
527                 return -1;
528
529         dpm = (DualPortMemory *) rambase;
530
531         memset(&sndmsg, 0, MSG_LEN);
532         sndmsg.msg_byte_cnt = 3;
533         sndmsg.type = cmReqType1;
534         sndmsg.class = cmReqClass0;
535         sndmsg.code = cmReqHWConfig;
536         memcpy_toio(&(dpm->req_queue[dpm->req_head++]), &sndmsg, MSG_LEN);
537         outb(0, iobase + 0x400);
538         pr_debug("Sent HWConfig message\n");
539         /*
540          * Wait for the response
541          */
542         x = 0;
543         while((inb(iobase + FIFOSTAT_OFFSET) & RF_HAS_DATA) && x < 100) {
544                 set_current_state(TASK_INTERRUPTIBLE);
545                 schedule_timeout(1);
546                 x++;
547         }
548         if(x == 100) {
549                 pr_debug("Timeout waiting for response\n");
550                 return -1;
551         }
552
553         memcpy_fromio(&rcvmsg, &(dpm->rsp_queue[dpm->rsp_tail]), MSG_LEN);
554         pr_debug("Got HWConfig response, status = 0x%x\n", rcvmsg.rsp_status);
555         memcpy(&hwci, &(rcvmsg.msg_data.HWCresponse), sizeof(HWConfig_pl));
556         pr_debug("Hardware Config: Interface: %s, RAM Size: %d, Serial: %s\n"
557                  "                 Part: %s, Rev: %s\n",
558                  hwci.st_u_sense ? "S/T" : "U", hwci.ram_size,
559                  hwci.serial_no, hwci.part_no, hwci.rev_no);
560
561         if(!strncmp(PRI_PARTNO, hwci.part_no, 6))
562                 return PRI_BOARD;
563         if(!strncmp(BRI_PARTNO, hwci.part_no, 6))
564                 return BRI_BOARD;
565                 
566         return -1;
567 }
568
569 module_init(sc_init);
570 module_exit(sc_exit);