?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
- Linus: more PageDirty / swapcache handling
[davej-history.git] / drivers / isdn / avmb1 / c4.c
blob4c0b5f0eb27ba4510f72dae4efb99bd522d4315d
1 /*
2 * $Id: c4.c,v 1.20.6.1 2000/11/28 12:02:45 kai Exp $
3 *
4 * Module for AVM C4 card.
5 *
6 * (c) Copyright 1999 by Carsten Paeth (calle@calle.in-berlin.de)
7 *
8 * $Log: c4.c,v $
9 * Revision 1.20.6.1 2000/11/28 12:02:45 kai
10 * MODULE_DEVICE_TABLE for 2.4
11 *
12 * Revision 1.20.2.2 2000/11/26 17:47:53 kai
13 * added PCI_DEV_TABLE for 2.4
14 *
15 * Revision 1.20.2.1 2000/11/26 17:14:19 kai
16 * fix device ids
17 * also needs patches to include/linux/pci_ids.h
18 *
19 * Revision 1.20 2000/11/23 20:45:14 kai
20 * fixed module_init/exit stuff
21 * Note: compiled-in kernel doesn't work pre 2.2.18 anymore.
22 *
23 * Revision 1.19 2000/11/19 17:02:47 kai
24 * compatibility cleanup - part 3
25 *
26 * Revision 1.18 2000/11/01 14:05:02 calle
27 * - use module_init/module_exit from linux/init.h.
28 * - all static struct variables are initialized with "membername:" now.
29 * - avm_cs.c, let it work with newer pcmcia-cs.
30 *
31 * Revision 1.17 2000/10/10 17:44:19 kai
32 * changes from/for 2.2.18
33 *
34 * Revision 1.16 2000/08/20 07:30:13 keil
35 * changes for 2.4
36 *
37 * Revision 1.15 2000/08/08 09:24:19 calle
38 * calls to pci_enable_device surounded by #ifndef COMPAT_HAS_2_2_PCI
39 *
40 * Revision 1.14 2000/08/04 12:20:08 calle
41 * - Fix unsigned/signed warning in the right way ...
42 *
43 * Revision 1.13 2000/07/20 10:21:21 calle
44 * Bugfix: driver will not be unregistered, if not cards were detected.
45 * this result in an oops in kcapi.c
46 *
47 * Revision 1.12 2000/06/19 16:51:53 keil
48 * don't free skb in irq context
49 *
50 * Revision 1.11 2000/06/19 15:11:24 keil
51 * avoid use of freed structs
52 * changes from 2.4.0-ac21
53 *
54 * Revision 1.10 2000/05/29 12:29:18 keil
55 * make pci_enable_dev compatible to 2.2 kernel versions
56 *
57 * Revision 1.9 2000/05/19 15:43:22 calle
58 * added calls to pci_device_start().
59 *
60 * Revision 1.8 2000/04/03 16:38:05 calle
61 * made suppress_pollack static.
62 *
63 * Revision 1.7 2000/04/03 13:29:24 calle
64 * make Tim Waugh happy (module unload races in 2.3.99-pre3).
65 * no real problem there, but now it is much cleaner ...
66 *
67 * Revision 1.6 2000/03/17 12:21:08 calle
68 * send patchvalues now working.
69 *
70 * Revision 1.5 2000/03/16 15:21:03 calle
71 * Bugfix in c4_remove: loop 5 times instead of 4 :-(
72 *
73 * Revision 1.4 2000/02/02 18:36:03 calle
74 * - Modules are now locked while init_module is running
75 * - fixed problem with memory mapping if address is not aligned
76 *
77 * Revision 1.3 2000/01/25 14:37:39 calle
78 * new message after successfull detection including card revision and
79 * used resources.
80 *
81 * Revision 1.2 2000/01/21 20:52:58 keil
82 * pci_find_subsys as local function for 2.2.X kernel
83 *
84 * Revision 1.1 2000/01/20 10:51:37 calle
85 * Added driver for C4.
86 *
87 *
88 */
89
90 #include <linux/config.h>
91 #include <linux/module.h>
92 #include <linux/kernel.h>
93 #include <linux/skbuff.h>
94 #include <linux/delay.h>
95 #include <linux/mm.h>
96 #include <linux/interrupt.h>
97 #include <linux/ioport.h>
98 #include <linux/pci.h>
99 #include <linux/capi.h>
100 #include <linux/init.h>
101 #include <asm/io.h>
102 #include <asm/uaccess.h>
103 #include <linux/netdevice.h>
104 #include "capicmd.h"
105 #include "capiutil.h"
106 #include "capilli.h"
107 #include "avmcard.h"
108
109 static char *revision = "$Revision: 1.20.6.1 $";
110
111 #undef CONFIG_C4_DEBUG
112 #undef CONFIG_C4_POLLDEBUG
113
114 /* ------------------------------------------------------------- */
115
116 static int suppress_pollack;
117
118 static struct pci_device_id c4_pci_tbl[] __initdata = {
119 { PCI_VENDOR_ID_DEC,PCI_DEVICE_ID_DEC_21285, PCI_VENDOR_ID_AVM, PCI_DEVICE_ID_AVM_C4 },
120 { } /* Terminating entry */
121 };
122
123 MODULE_DEVICE_TABLE(pci, c4_pci_tbl);
124 MODULE_AUTHOR("Carsten Paeth <calle@calle.in-berlin.de>");
125 MODULE_PARM(suppress_pollack, "0-1i");
126
127 /* ------------------------------------------------------------- */
128
129 static struct capi_driver_interface *di;
130
131 /* ------------------------------------------------------------- */
132
133 static void c4_dispatch_tx(avmcard *card);
134
135 /* ------------------------------------------------------------- */
136
137 #define DC21285_DRAM_A0MR 0x40000000
138 #define DC21285_DRAM_A1MR 0x40004000
139 #define DC21285_DRAM_A2MR 0x40008000
140 #define DC21285_DRAM_A3MR 0x4000C000
141
142 #define CAS_OFFSET 0x88
143
144 #define DC21285_ARMCSR_BASE 0x42000000
145
146 #define PCI_OUT_INT_STATUS 0x30
147 #define PCI_OUT_INT_MASK 0x34
148 #define MAILBOX_0 0x50
149 #define MAILBOX_1 0x54
150 #define MAILBOX_2 0x58
151 #define MAILBOX_3 0x5C
152 #define DOORBELL 0x60
153 #define DOORBELL_SETUP 0x64
154
155 #define CHAN_1_CONTROL 0x90
156 #define CHAN_2_CONTROL 0xB0
157 #define DRAM_TIMING 0x10C
158 #define DRAM_ADDR_SIZE_0 0x110
159 #define DRAM_ADDR_SIZE_1 0x114
160 #define DRAM_ADDR_SIZE_2 0x118
161 #define DRAM_ADDR_SIZE_3 0x11C
162 #define SA_CONTROL 0x13C
163 #define XBUS_CYCLE 0x148
164 #define XBUS_STROBE 0x14C
165 #define DBELL_PCI_MASK 0x150
166 #define DBELL_SA_MASK 0x154
167
168 #define SDRAM_SIZE 0x1000000
169
170 /* ------------------------------------------------------------- */
171
172 #define MBOX_PEEK_POKE MAILBOX_0
173
174 #define DBELL_ADDR 0x01
175 #define DBELL_DATA 0x02
176 #define DBELL_RNWR 0x40
177 #define DBELL_INIT 0x80
178
179 /* ------------------------------------------------------------- */
180
181 #define MBOX_UP_ADDR MAILBOX_0
182 #define MBOX_UP_LEN MAILBOX_1
183 #define MBOX_DOWN_ADDR MAILBOX_2
184 #define MBOX_DOWN_LEN MAILBOX_3
185
186 #define DBELL_UP_HOST 0x00000100
187 #define DBELL_UP_ARM 0x00000200
188 #define DBELL_DOWN_HOST 0x00000400
189 #define DBELL_DOWN_ARM 0x00000800
190 #define DBELL_RESET_HOST 0x40000000
191 #define DBELL_RESET_ARM 0x80000000
192
193 /* ------------------------------------------------------------- */
194
195 #define DRAM_TIMING_DEF 0x001A01A5
196 #define DRAM_AD_SZ_DEF0 0x00000045
197 #define DRAM_AD_SZ_NULL 0x00000000
198
199 #define SA_CTL_ALLRIGHT 0x64AA0271
200
201 #define INIT_XBUS_CYCLE 0x100016DB
202 #define INIT_XBUS_STROBE 0xF1F1F1F1
203
204 /* ------------------------------------------------------------- */
205
206 #define RESET_TIMEOUT (15*HZ) /* 15 sec */
207 #define PEEK_POKE_TIMEOUT (HZ/10) /* 0.1 sec */
208
209 /* ------------------------------------------------------------- */
210
211 #define c4outmeml(addr, value) writel(value, addr)
212 #define c4inmeml(addr) readl(addr)
213 #define c4outmemw(addr, value) writew(value, addr)
214 #define c4inmemw(addr) readw(addr)
215 #define c4outmemb(addr, value) writeb(value, addr)
216 #define c4inmemb(addr) readb(addr)
217
218 /* ------------------------------------------------------------- */
219
220 static inline int wait_for_doorbell(avmcard *card, unsigned long t)
221 {
222 unsigned long stop;
223
224 stop = jiffies + t;
225 while (c4inmeml(card->mbase+DOORBELL) != 0xffffffff) {
226 if (!time_before(jiffies, stop))
227 return -1;
228 }
229 return 0;
230 }
231
232 static int c4_poke(avmcard *card, unsigned long off, unsigned long value)
233 {
234
235 if (wait_for_doorbell(card, HZ/10) < 0)
236 return -1;
237
238 c4outmeml(card->mbase+MBOX_PEEK_POKE, off);
239 c4outmeml(card->mbase+DOORBELL, DBELL_ADDR);
240
241 if (wait_for_doorbell(card, HZ/10) < 0)
242 return -1;
243
244 c4outmeml(card->mbase+MBOX_PEEK_POKE, value);
245 c4outmeml(card->mbase+DOORBELL, DBELL_DATA | DBELL_ADDR);
246
247 return 0;
248 }
249
250 static int c4_peek(avmcard *card, unsigned long off, unsigned long *valuep)
251 {
252 if (wait_for_doorbell(card, HZ/10) < 0)
253 return -1;
254
255 c4outmeml(card->mbase+MBOX_PEEK_POKE, off);
256 c4outmeml(card->mbase+DOORBELL, DBELL_RNWR | DBELL_ADDR);
257
258 if (wait_for_doorbell(card, HZ/10) < 0)
259 return -1;
260
261 *valuep = c4inmeml(card->mbase+MBOX_PEEK_POKE);
262
263 return 0;
264 }
265
266 /* ------------------------------------------------------------- */
267
268 static int c4_load_t4file(avmcard *card, capiloaddatapart * t4file)
269 {
270 __u32 val;
271 unsigned char *dp;
272 int left, retval;
273 __u32 loadoff = 0;
274
275 dp = t4file->data;
276 left = t4file->len;
277 while (left >= sizeof(__u32)) {
278 if (t4file->user) {
279 retval = copy_from_user(&val, dp, sizeof(val));
280 if (retval)
281 return -EFAULT;
282 } else {
283 memcpy(&val, dp, sizeof(val));
284 }
285 if (c4_poke(card, loadoff, val)) {
286 printk(KERN_ERR "%s: corrupted firmware file ?\n",
287 card->name);
288 return -EIO;
289 }
290 left -= sizeof(__u32);
291 dp += sizeof(__u32);
292 loadoff += sizeof(__u32);
293 }
294 if (left) {
295 val = 0;
296 if (t4file->user) {
297 retval = copy_from_user(&val, dp, left);
298 if (retval)
299 return -EFAULT;
300 } else {
301 memcpy(&val, dp, left);
302 }
303 if (c4_poke(card, loadoff, val)) {
304 printk(KERN_ERR "%s: corrupted firmware file ?\n",
305 card->name);
306 return -EIO;
307 }
308 }
309 return 0;
310 }
311
312 /* ------------------------------------------------------------- */
313
314 static inline void _put_byte(void **pp, __u8 val)
315 {
316 __u8 *s = *pp;
317 *s++ = val;
318 *pp = s;
319 }
320
321 static inline void _put_word(void **pp, __u32 val)
322 {
323 __u8 *s = *pp;
324 *s++ = val & 0xff;
325 *s++ = (val >> 8) & 0xff;
326 *s++ = (val >> 16) & 0xff;
327 *s++ = (val >> 24) & 0xff;
328 *pp = s;
329 }
330
331 static inline void _put_slice(void **pp, unsigned char *dp, unsigned int len)
332 {
333 unsigned i = len;
334 _put_word(pp, i);
335 while (i-- > 0)
336 _put_byte(pp, *dp++);
337 }
338
339 static inline __u8 _get_byte(void **pp)
340 {
341 __u8 *s = *pp;
342 __u8 val;
343 val = *s++;
344 *pp = s;
345 return val;
346 }
347
348 static inline __u32 _get_word(void **pp)
349 {
350 __u8 *s = *pp;
351 __u32 val;
352 val = *s++;
353 val |= (*s++ << 8);
354 val |= (*s++ << 16);
355 val |= (*s++ << 24);
356 *pp = s;
357 return val;
358 }
359
360 static inline __u32 _get_slice(void **pp, unsigned char *dp)
361 {
362 unsigned int len, i;
363
364 len = i = _get_word(pp);
365 while (i-- > 0) *dp++ = _get_byte(pp);
366 return len;
367 }
368
369 /* ------------------------------------------------------------- */
370
371 static void c4_reset(avmcard *card)
372 {
373 unsigned long stop;
374
375 c4outmeml(card->mbase+DOORBELL, DBELL_RESET_ARM);
376
377 stop = jiffies + HZ*10;
378 while (c4inmeml(card->mbase+DOORBELL) != 0xffffffff) {
379 if (!time_before(jiffies, stop))
380 return;
381 c4outmeml(card->mbase+DOORBELL, DBELL_ADDR);
382 }
383
384 c4_poke(card, DC21285_ARMCSR_BASE + CHAN_1_CONTROL, 0);
385 c4_poke(card, DC21285_ARMCSR_BASE + CHAN_2_CONTROL, 0);
386 }
387
388 /* ------------------------------------------------------------- */
389
390 static int c4_detect(avmcard *card)
391 {
392 unsigned long stop, dummy;
393
394 c4outmeml(card->mbase+PCI_OUT_INT_MASK, 0x0c);
395 if (c4inmeml(card->mbase+PCI_OUT_INT_MASK) != 0x0c)
396 return 1;
397
398 c4outmeml(card->mbase+DOORBELL, DBELL_RESET_ARM);
399
400 stop = jiffies + HZ*10;
401 while (c4inmeml(card->mbase+DOORBELL) != 0xffffffff) {
402 if (!time_before(jiffies, stop))
403 return 2;
404 c4outmeml(card->mbase+DOORBELL, DBELL_ADDR);
405 }
406
407 c4_poke(card, DC21285_ARMCSR_BASE + CHAN_1_CONTROL, 0);
408 c4_poke(card, DC21285_ARMCSR_BASE + CHAN_2_CONTROL, 0);
409
410 c4outmeml(card->mbase+MAILBOX_0, 0x55aa55aa);
411 if (c4inmeml(card->mbase+MAILBOX_0) != 0x55aa55aa) return 3;
412
413 c4outmeml(card->mbase+MAILBOX_0, 0xaa55aa55);
414 if (c4inmeml(card->mbase+MAILBOX_0) != 0xaa55aa55) return 4;
415
416 if (c4_poke(card, DC21285_ARMCSR_BASE+DBELL_SA_MASK, 0)) return 5;
417 if (c4_poke(card, DC21285_ARMCSR_BASE+DBELL_PCI_MASK, 0)) return 6;
418 if (c4_poke(card, DC21285_ARMCSR_BASE+SA_CONTROL, SA_CTL_ALLRIGHT))
419 return 7;
420 if (c4_poke(card, DC21285_ARMCSR_BASE+XBUS_CYCLE, INIT_XBUS_CYCLE))
421 return 8;
422 if (c4_poke(card, DC21285_ARMCSR_BASE+XBUS_STROBE, INIT_XBUS_STROBE))
423 return 8;
424 if (c4_poke(card, DC21285_ARMCSR_BASE+DRAM_TIMING, 0)) return 9;
425
426 mdelay(1);
427
428 if (c4_peek(card, DC21285_DRAM_A0MR, &dummy)) return 10;
429 if (c4_peek(card, DC21285_DRAM_A1MR, &dummy)) return 11;
430 if (c4_peek(card, DC21285_DRAM_A2MR, &dummy)) return 12;
431 if (c4_peek(card, DC21285_DRAM_A3MR, &dummy)) return 13;
432
433 if (c4_poke(card, DC21285_DRAM_A0MR+CAS_OFFSET, 0)) return 14;
434 if (c4_poke(card, DC21285_DRAM_A1MR+CAS_OFFSET, 0)) return 15;
435 if (c4_poke(card, DC21285_DRAM_A2MR+CAS_OFFSET, 0)) return 16;
436 if (c4_poke(card, DC21285_DRAM_A3MR+CAS_OFFSET, 0)) return 17;
437
438 mdelay(1);
439
440 if (c4_poke(card, DC21285_ARMCSR_BASE+DRAM_TIMING, DRAM_TIMING_DEF))
441 return 18;
442
443 if (c4_poke(card, DC21285_ARMCSR_BASE+DRAM_ADDR_SIZE_0,DRAM_AD_SZ_DEF0))
444 return 19;
445 if (c4_poke(card, DC21285_ARMCSR_BASE+DRAM_ADDR_SIZE_1,DRAM_AD_SZ_NULL))
446 return 20;
447 if (c4_poke(card, DC21285_ARMCSR_BASE+DRAM_ADDR_SIZE_2,DRAM_AD_SZ_NULL))
448 return 21;
449 if (c4_poke(card, DC21285_ARMCSR_BASE+DRAM_ADDR_SIZE_3,DRAM_AD_SZ_NULL))
450 return 22;
451
452 /* Transputer test */
453
454 if ( c4_poke(card, 0x000000, 0x11111111)
455 || c4_poke(card, 0x400000, 0x22222222)
456 || c4_poke(card, 0x800000, 0x33333333)
457 || c4_poke(card, 0xC00000, 0x44444444))
458 return 23;
459
460 if ( c4_peek(card, 0x000000, &dummy) || dummy != 0x11111111
461 || c4_peek(card, 0x400000, &dummy) || dummy != 0x22222222
462 || c4_peek(card, 0x800000, &dummy) || dummy != 0x33333333
463 || c4_peek(card, 0xC00000, &dummy) || dummy != 0x44444444)
464 return 24;
465
466 if ( c4_poke(card, 0x000000, 0x55555555)
467 || c4_poke(card, 0x400000, 0x66666666)
468 || c4_poke(card, 0x800000, 0x77777777)
469 || c4_poke(card, 0xC00000, 0x88888888))
470 return 25;
471
472 if ( c4_peek(card, 0x000000, &dummy) || dummy != 0x55555555
473 || c4_peek(card, 0x400000, &dummy) || dummy != 0x66666666
474 || c4_peek(card, 0x800000, &dummy) || dummy != 0x77777777
475 || c4_peek(card, 0xC00000, &dummy) || dummy != 0x88888888)
476 return 26;
477
478 return 0;
479 }
480
481 /* ------------------------------------------------------------- */
482
483 static void c4_dispatch_tx(avmcard *card)
484 {
485 avmcard_dmainfo *dma = card->dma;
486 unsigned long flags;
487 struct sk_buff *skb;
488 __u8 cmd, subcmd;
489 __u16 len;
490 __u32 txlen;
491 void *p;
492
493 save_flags(flags);
494 cli();
495
496 if (card->csr & DBELL_DOWN_ARM) { /* tx busy */
497 restore_flags(flags);
498 return;
499 }
500
501 skb = skb_dequeue(&dma->send_queue);
502 if (!skb) {
503 #ifdef CONFIG_C4_DEBUG
504 printk(KERN_DEBUG "%s: tx underrun\n", card->name);
505 #endif
506 restore_flags(flags);
507 return;
508 }
509
510 len = CAPIMSG_LEN(skb->data);
511
512 if (len) {
513 cmd = CAPIMSG_COMMAND(skb->data);
514 subcmd = CAPIMSG_SUBCOMMAND(skb->data);
515
516 p = dma->sendbuf;
517
518 if (CAPICMD(cmd, subcmd) == CAPI_DATA_B3_REQ) {
519 __u16 dlen = CAPIMSG_DATALEN(skb->data);
520 _put_byte(&p, SEND_DATA_B3_REQ);
521 _put_slice(&p, skb->data, len);
522 _put_slice(&p, skb->data + len, dlen);
523 } else {
524 _put_byte(&p, SEND_MESSAGE);
525 _put_slice(&p, skb->data, len);
526 }
527 txlen = (__u8 *)p - (__u8 *)dma->sendbuf;
528 #ifdef CONFIG_C4_DEBUG
529 printk(KERN_DEBUG "%s: tx put msg len=%d\n", card->name, txlen);
530 #endif
531 } else {
532 txlen = skb->len-2;
533 #ifdef CONFIG_C4_POLLDEBUG
534 if (skb->data[2] == SEND_POLLACK)
535 printk(KERN_INFO "%s: ack to c4\n", card->name);
536 #endif
537 #ifdef CONFIG_C4_DEBUG
538 printk(KERN_DEBUG "%s: tx put 0x%x len=%d\n",
539 card->name, skb->data[2], txlen);
540 #endif
541 memcpy(dma->sendbuf, skb->data+2, skb->len-2);
542 }
543 txlen = (txlen + 3) & ~3;
544
545 c4outmeml(card->mbase+MBOX_DOWN_ADDR, virt_to_phys(dma->sendbuf));
546 c4outmeml(card->mbase+MBOX_DOWN_LEN, txlen);
547
548 card->csr |= DBELL_DOWN_ARM;
549
550 c4outmeml(card->mbase+DOORBELL, DBELL_DOWN_ARM);
551
552 restore_flags(flags);
553 dev_kfree_skb_any(skb);
554 }
555
556 /* ------------------------------------------------------------- */
557
558 static void queue_pollack(avmcard *card)
559 {
560 struct sk_buff *skb;
561 void *p;
562
563 skb = alloc_skb(3, GFP_ATOMIC);
564 if (!skb) {
565 printk(KERN_CRIT "%s: no memory, lost poll ack\n",
566 card->name);
567 return;
568 }
569 p = skb->data;
570 _put_byte(&p, 0);
571 _put_byte(&p, 0);
572 _put_byte(&p, SEND_POLLACK);
573 skb_put(skb, (__u8 *)p - (__u8 *)skb->data);
574
575 skb_queue_tail(&card->dma->send_queue, skb);
576 c4_dispatch_tx(card);
577 }
578
579 /* ------------------------------------------------------------- */
580
581 static void c4_handle_rx(avmcard *card)
582 {
583 avmcard_dmainfo *dma = card->dma;
584 struct capi_ctr *ctrl;
585 avmctrl_info *cinfo;
586 struct sk_buff *skb;
587 void *p = dma->recvbuf;
588 __u32 ApplId, MsgLen, DataB3Len, NCCI, WindowSize;
589 __u8 b1cmd = _get_byte(&p);
590 __u32 cidx;
591
592
593 #ifdef CONFIG_C4_DEBUG
594 printk(KERN_DEBUG "%s: rx 0x%x len=%lu\n", card->name,
595 b1cmd, (unsigned long)dma->recvlen);
596 #endif
597
598 switch (b1cmd) {
599 case RECEIVE_DATA_B3_IND:
600
601 ApplId = (unsigned) _get_word(&p);
602 MsgLen = _get_slice(&p, card->msgbuf);
603 DataB3Len = _get_slice(&p, card->databuf);
604 cidx = CAPIMSG_CONTROLLER(card->msgbuf)-card->cardnr;
605 if (cidx > 3) cidx = 0;
606 ctrl = card->ctrlinfo[cidx].capi_ctrl;
607
608 if (MsgLen < 30) { /* not CAPI 64Bit */
609 memset(card->msgbuf+MsgLen, 0, 30-MsgLen);
610 MsgLen = 30;
611 CAPIMSG_SETLEN(card->msgbuf, 30);
612 }
613 if (!(skb = alloc_skb(DataB3Len+MsgLen, GFP_ATOMIC))) {
614 printk(KERN_ERR "%s: incoming packet dropped\n",
615 card->name);
616 } else {
617 memcpy(skb_put(skb, MsgLen), card->msgbuf, MsgLen);
618 memcpy(skb_put(skb, DataB3Len), card->databuf, DataB3Len);
619 ctrl->handle_capimsg(ctrl, ApplId, skb);
620 }
621 break;
622
623 case RECEIVE_MESSAGE:
624
625 ApplId = (unsigned) _get_word(&p);
626 MsgLen = _get_slice(&p, card->msgbuf);
627 cidx = CAPIMSG_CONTROLLER(card->msgbuf)-card->cardnr;
628 if (cidx > 3) cidx = 0;
629 ctrl = card->ctrlinfo[cidx].capi_ctrl;
630
631 if (!(skb = alloc_skb(MsgLen, GFP_ATOMIC))) {
632 printk(KERN_ERR "%s: incoming packet dropped\n",
633 card->name);
634 } else {
635 memcpy(skb_put(skb, MsgLen), card->msgbuf, MsgLen);
636 ctrl->handle_capimsg(ctrl, ApplId, skb);
637 }
638 break;
639
640 case RECEIVE_NEW_NCCI:
641
642 ApplId = _get_word(&p);
643 NCCI = _get_word(&p);
644 WindowSize = _get_word(&p);
645 cidx = (NCCI&0x7f) - card->cardnr;
646 if (cidx > 3) cidx = 0;
647 ctrl = card->ctrlinfo[cidx].capi_ctrl;
648
649 ctrl->new_ncci(ctrl, ApplId, NCCI, WindowSize);
650
651 break;
652
653 case RECEIVE_FREE_NCCI:
654
655 ApplId = _get_word(&p);
656 NCCI = _get_word(&p);
657
658 if (NCCI != 0xffffffff) {
659 cidx = (NCCI&0x7f) - card->cardnr;
660 if (cidx > 3) cidx = 0;
661 ctrl = card->ctrlinfo[cidx].capi_ctrl;
662 ctrl->free_ncci(ctrl, ApplId, NCCI);
663 } else {
664 for (cidx=0; cidx < 4; cidx++) {
665 ctrl = card->ctrlinfo[cidx].capi_ctrl;
666 ctrl->appl_released(ctrl, ApplId);
667 }
668 }
669 break;
670
671 case RECEIVE_START:
672 #ifdef CONFIG_C4_POLLDEBUG
673 printk(KERN_INFO "%s: poll from c4\n", card->name);
674 #endif
675 if (!suppress_pollack)
676 queue_pollack(card);
677 for (cidx=0; cidx < 4; cidx++) {
678 ctrl = card->ctrlinfo[cidx].capi_ctrl;
679 ctrl->resume_output(ctrl);
680 }
681 break;
682
683 case RECEIVE_STOP:
684 for (cidx=0; cidx < 4; cidx++) {
685 ctrl = card->ctrlinfo[cidx].capi_ctrl;
686 ctrl->suspend_output(ctrl);
687 }
688 break;
689
690 case RECEIVE_INIT:
691
692 cidx = card->nlogcontr++;
693 cinfo = &card->ctrlinfo[cidx];
694 ctrl = cinfo->capi_ctrl;
695 cinfo->versionlen = _get_slice(&p, cinfo->versionbuf);
696 b1_parse_version(cinfo);
697 printk(KERN_INFO "%s: %s-card (%s) now active\n",
698 card->name,
699 cinfo->version[VER_CARDTYPE],
700 cinfo->version[VER_DRIVER]);
701 ctrl->ready(cinfo->capi_ctrl);
702 break;
703
704 case RECEIVE_TASK_READY:
705 ApplId = (unsigned) _get_word(&p);
706 MsgLen = _get_slice(&p, card->msgbuf);
707 card->msgbuf[MsgLen] = 0;
708 while ( MsgLen > 0
709 && ( card->msgbuf[MsgLen-1] == '\n'
710 || card->msgbuf[MsgLen-1] == '\r')) {
711 card->msgbuf[MsgLen-1] = 0;
712 MsgLen--;
713 }
714 printk(KERN_INFO "%s: task %d \"%s\" ready.\n",
715 card->name, ApplId, card->msgbuf);
716 break;
717
718 case RECEIVE_DEBUGMSG:
719 MsgLen = _get_slice(&p, card->msgbuf);
720 card->msgbuf[MsgLen] = 0;
721 while ( MsgLen > 0
722 && ( card->msgbuf[MsgLen-1] == '\n'
723 || card->msgbuf[MsgLen-1] == '\r')) {
724 card->msgbuf[MsgLen-1] = 0;
725 MsgLen--;
726 }
727 printk(KERN_INFO "%s: DEBUG: %s\n", card->name, card->msgbuf);
728 break;
729
730 default:
731 printk(KERN_ERR "%s: c4_interrupt: 0x%x ???\n",
732 card->name, b1cmd);
733 return;
734 }
735 }
736
737 /* ------------------------------------------------------------- */
738
739 static void c4_handle_interrupt(avmcard *card)
740 {
741 __u32 status = c4inmeml(card->mbase+DOORBELL);
742
743 if (status & DBELL_RESET_HOST) {
744 int i;
745 c4outmeml(card->mbase+PCI_OUT_INT_MASK, 0x0c);
746 printk(KERN_ERR "%s: unexpected reset\n", card->name);
747 for (i=0; i < 4; i++) {
748 avmctrl_info *cinfo = &card->ctrlinfo[i];
749 memset(cinfo->version, 0, sizeof(cinfo->version));
750 if (cinfo->capi_ctrl)
751 cinfo->capi_ctrl->reseted(cinfo->capi_ctrl);
752 }
753 return;
754 }
755
756 status &= (DBELL_UP_HOST | DBELL_DOWN_HOST);
757 if (!status)
758 return;
759 c4outmeml(card->mbase+DOORBELL, status);
760
761 if ((status & DBELL_UP_HOST) != 0) {
762 card->dma->recvlen = c4inmeml(card->mbase+MBOX_UP_LEN);
763 c4outmeml(card->mbase+MBOX_UP_LEN, 0);
764 c4_handle_rx(card);
765 card->dma->recvlen = 0;
766 c4outmeml(card->mbase+MBOX_UP_LEN, sizeof(card->dma->recvbuf));
767 c4outmeml(card->mbase+DOORBELL, DBELL_UP_ARM);
768 }
769
770 if ((status & DBELL_DOWN_HOST) != 0) {
771 card->csr &= ~DBELL_DOWN_ARM;
772 c4_dispatch_tx(card);
773 } else if (card->csr & DBELL_DOWN_HOST) {
774 if (c4inmeml(card->mbase+MBOX_DOWN_LEN) == 0) {
775 card->csr &= ~DBELL_DOWN_ARM;
776 c4_dispatch_tx(card);
777 }
778 }
779 }
780
781 static void c4_interrupt(int interrupt, void *devptr, struct pt_regs *regs)
782 {
783 avmcard *card;
784
785 card = (avmcard *) devptr;
786
787 if (!card) {
788 printk(KERN_WARNING "%s: interrupt: wrong device\n", card->name);
789 return;
790 }
791 if (card->interrupt) {
792 printk(KERN_ERR "%s: reentering interrupt hander\n",
793 card->name);
794 return;
795 }
796
797 card->interrupt = 1;
798
799 c4_handle_interrupt(card);
800
801 card->interrupt = 0;
802 }
803
804 /* ------------------------------------------------------------- */
805
806 static void c4_send_init(avmcard *card)
807 {
808 struct sk_buff *skb;
809 void *p;
810
811 skb = alloc_skb(15, GFP_ATOMIC);
812 if (!skb) {
813 printk(KERN_CRIT "%s: no memory, lost register appl.\n",
814 card->name);
815 return;
816 }
817 p = skb->data;
818 _put_byte(&p, 0);
819 _put_byte(&p, 0);
820 _put_byte(&p, SEND_INIT);
821 _put_word(&p, AVM_NAPPS);
822 _put_word(&p, AVM_NCCI_PER_CHANNEL*30);
823 _put_word(&p, card->cardnr - 1);
824 skb_put(skb, (__u8 *)p - (__u8 *)skb->data);
825
826 skb_queue_tail(&card->dma->send_queue, skb);
827 c4_dispatch_tx(card);
828 }
829
830 static int queue_sendconfigword(avmcard *card, __u32 val)
831 {
832 struct sk_buff *skb;
833 void *p;
834
835 skb = alloc_skb(3+4, GFP_ATOMIC);
836 if (!skb) {
837 printk(KERN_CRIT "%s: no memory, send config\n",
838 card->name);
839 return -ENOMEM;
840 }
841 p = skb->data;
842 _put_byte(&p, 0);
843 _put_byte(&p, 0);
844 _put_byte(&p, SEND_CONFIG);
845 _put_word(&p, val);
846 skb_put(skb, (__u8 *)p - (__u8 *)skb->data);
847
848 skb_queue_tail(&card->dma->send_queue, skb);
849 c4_dispatch_tx(card);
850 return 0;
851 }
852
853 static int queue_sendconfig(avmcard *card, char cval[4])
854 {
855 struct sk_buff *skb;
856 void *p;
857
858 skb = alloc_skb(3+4, GFP_ATOMIC);
859 if (!skb) {
860 printk(KERN_CRIT "%s: no memory, send config\n",
861 card->name);
862 return -ENOMEM;
863 }
864 p = skb->data;
865 _put_byte(&p, 0);
866 _put_byte(&p, 0);
867 _put_byte(&p, SEND_CONFIG);
868 _put_byte(&p, cval[0]);
869 _put_byte(&p, cval[1]);
870 _put_byte(&p, cval[2]);
871 _put_byte(&p, cval[3]);
872 skb_put(skb, (__u8 *)p - (__u8 *)skb->data);
873
874 skb_queue_tail(&card->dma->send_queue, skb);
875 c4_dispatch_tx(card);
876 return 0;
877 }
878
879 static int c4_send_config(avmcard *card, capiloaddatapart * config)
880 {
881 __u8 val[4];
882 unsigned char *dp;
883 int left, retval;
884
885 if ((retval = queue_sendconfigword(card, 1)) != 0)
886 return retval;
887 if ((retval = queue_sendconfigword(card, config->len)) != 0)
888 return retval;
889
890 dp = config->data;
891 left = config->len;
892 while (left >= sizeof(__u32)) {
893 if (config->user) {
894 retval = copy_from_user(val, dp, sizeof(val));
895 if (retval)
896 return -EFAULT;
897 } else {
898 memcpy(val, dp, sizeof(val));
899 }
900 if ((retval = queue_sendconfig(card, val)) != 0)
901 return retval;
902 left -= sizeof(val);
903 dp += sizeof(val);
904 }
905 if (left) {
906 memset(val, 0, sizeof(val));
907 if (config->user) {
908 retval = copy_from_user(&val, dp, left);
909 if (retval)
910 return -EFAULT;
911 } else {
912 memcpy(&val, dp, left);
913 }
914 if ((retval = queue_sendconfig(card, val)) != 0)
915 return retval;
916 }
917
918 return 0;
919 }
920
921 static int c4_load_firmware(struct capi_ctr *ctrl, capiloaddata *data)
922 {
923 avmctrl_info *cinfo = (avmctrl_info *)(ctrl->driverdata);
924 avmcard *card = cinfo->card;
925 unsigned long flags;
926 int retval;
927
928 if ((retval = c4_load_t4file(card, &data->firmware))) {
929 printk(KERN_ERR "%s: failed to load t4file!!\n",
930 card->name);
931 c4_reset(card);
932 return retval;
933 }
934
935 save_flags(flags);
936 cli();
937
938 card->csr = 0;
939 c4outmeml(card->mbase+MBOX_UP_LEN, 0);
940 c4outmeml(card->mbase+MBOX_DOWN_LEN, 0);
941 c4outmeml(card->mbase+DOORBELL, DBELL_INIT);
942 mdelay(1);
943 c4outmeml(card->mbase+DOORBELL,
944 DBELL_UP_HOST | DBELL_DOWN_HOST | DBELL_RESET_HOST);
945
946 c4outmeml(card->mbase+PCI_OUT_INT_MASK, 0x08);
947
948 card->dma->recvlen = 0;
949 c4outmeml(card->mbase+MBOX_UP_ADDR, virt_to_phys(card->dma->recvbuf));
950 c4outmeml(card->mbase+MBOX_UP_LEN, sizeof(card->dma->recvbuf));
951 c4outmeml(card->mbase+DOORBELL, DBELL_UP_ARM);
952 restore_flags(flags);
953
954 if (data->configuration.len > 0 && data->configuration.data) {
955 retval = c4_send_config(card, &data->configuration);
956 if (retval) {
957 printk(KERN_ERR "%s: failed to set config!!\n",
958 card->name);
959 c4_reset(card);
960 return retval;
961 }
962 }
963
964 c4_send_init(card);
965
966 return 0;
967 }
968
969
970 void c4_reset_ctr(struct capi_ctr *ctrl)
971 {
972 avmcard *card = ((avmctrl_info *)(ctrl->driverdata))->card;
973 avmctrl_info *cinfo;
974 int i;
975
976 c4_reset(card);
977
978 for (i=0; i < 4; i++) {
979 cinfo = &card->ctrlinfo[i];
980 memset(cinfo->version, 0, sizeof(cinfo->version));
981 if (cinfo->capi_ctrl)
982 cinfo->capi_ctrl->reseted(cinfo->capi_ctrl);
983 }
984 }
985
986 static void c4_remove_ctr(struct capi_ctr *ctrl)
987 {
988 avmcard *card = ((avmctrl_info *)(ctrl->driverdata))->card;
989 avmctrl_info *cinfo;
990 int i;
991
992 c4_reset(card);
993
994 for (i=0; i < 4; i++) {
995 cinfo = &card->ctrlinfo[i];
996 if (cinfo->capi_ctrl) {
997 di->detach_ctr(cinfo->capi_ctrl);
998 cinfo->capi_ctrl = NULL;
999 }
1000 }
1001
1002 free_irq(card->irq, card);
1003 iounmap((void *) (((unsigned long) card->mbase) & PAGE_MASK));
1004 release_region(card->port, AVMB1_PORTLEN);
1005 ctrl->driverdata = 0;
1006 kfree(card->ctrlinfo);
1007 kfree(card->dma);
1008 kfree(card);
1009
1010 MOD_DEC_USE_COUNT;
1011 }
1012
1013 /* ------------------------------------------------------------- */
1014
1015
1016 void c4_register_appl(struct capi_ctr *ctrl,
1017 __u16 appl,
1018 capi_register_params *rp)
1019 {
1020 avmctrl_info *cinfo = (avmctrl_info *)(ctrl->driverdata);
1021 avmcard *card = cinfo->card;
1022 struct sk_buff *skb;
1023 int want = rp->level3cnt;
1024 int nconn;
1025 void *p;
1026
1027 if (ctrl->cnr == card->cardnr) {
1028
1029 if (want > 0) nconn = want;
1030 else nconn = ctrl->profile.nbchannel * 4 * -want;
1031 if (nconn == 0) nconn = ctrl->profile.nbchannel * 4;
1032
1033 skb = alloc_skb(23, GFP_ATOMIC);
1034 if (!skb) {
1035 printk(KERN_CRIT "%s: no memory, lost register appl.\n",
1036 card->name);
1037 return;
1038 }
1039 p = skb->data;
1040 _put_byte(&p, 0);
1041 _put_byte(&p, 0);
1042 _put_byte(&p, SEND_REGISTER);
1043 _put_word(&p, appl);
1044 _put_word(&p, 1024 * (nconn+1));
1045 _put_word(&p, nconn);
1046 _put_word(&p, rp->datablkcnt);
1047 _put_word(&p, rp->datablklen);
1048 skb_put(skb, (__u8 *)p - (__u8 *)skb->data);
1049
1050 skb_queue_tail(&card->dma->send_queue, skb);
1051 c4_dispatch_tx(card);
1052 }
1053
1054 ctrl->appl_registered(ctrl, appl);
1055 }
1056
1057 /* ------------------------------------------------------------- */
1058
1059 void c4_release_appl(struct capi_ctr *ctrl, __u16 appl)
1060 {
1061 avmctrl_info *cinfo = (avmctrl_info *)(ctrl->driverdata);
1062 avmcard *card = cinfo->card;
1063 struct sk_buff *skb;
1064 void *p;
1065
1066 if (ctrl->cnr == card->cardnr) {
1067 skb = alloc_skb(7, GFP_ATOMIC);
1068 if (!skb) {
1069 printk(KERN_CRIT "%s: no memory, lost release appl.\n",
1070 card->name);
1071 return;
1072 }
1073 p = skb->data;
1074 _put_byte(&p, 0);
1075 _put_byte(&p, 0);
1076 _put_byte(&p, SEND_RELEASE);
1077 _put_word(&p, appl);
1078
1079 skb_put(skb, (__u8 *)p - (__u8 *)skb->data);
1080 skb_queue_tail(&card->dma->send_queue, skb);
1081 c4_dispatch_tx(card);
1082 }
1083 }
1084
1085 /* ------------------------------------------------------------- */
1086
1087
1088 static void c4_send_message(struct capi_ctr *ctrl, struct sk_buff *skb)
1089 {
1090 avmctrl_info *cinfo = (avmctrl_info *)(ctrl->driverdata);
1091 avmcard *card = cinfo->card;
1092 skb_queue_tail(&card->dma->send_queue, skb);
1093 c4_dispatch_tx(card);
1094 }
1095
1096 /* ------------------------------------------------------------- */
1097
1098 static char *c4_procinfo(struct capi_ctr *ctrl)
1099 {
1100 avmctrl_info *cinfo = (avmctrl_info *)(ctrl->driverdata);
1101
1102 if (!cinfo)
1103 return "";
1104 sprintf(cinfo->infobuf, "%s %s 0x%x %d 0x%lx",
1105 cinfo->cardname[0] ? cinfo->cardname : "-",
1106 cinfo->version[VER_DRIVER] ? cinfo->version[VER_DRIVER] : "-",
1107 cinfo->card ? cinfo->card->port : 0x0,
1108 cinfo->card ? cinfo->card->irq : 0,
1109 cinfo->card ? cinfo->card->membase : 0
1110 );
1111 return cinfo->infobuf;
1112 }
1113
1114 static int c4_read_proc(char *page, char **start, off_t off,
1115 int count, int *eof, struct capi_ctr *ctrl)
1116 {
1117 avmctrl_info *cinfo = (avmctrl_info *)(ctrl->driverdata);
1118 avmcard *card = cinfo->card;
1119 __u8 flag;
1120 int len = 0;
1121 char *s;
1122
1123 len += sprintf(page+len, "%-16s %s\n", "name", card->name);
1124 len += sprintf(page+len, "%-16s 0x%x\n", "io", card->port);
1125 len += sprintf(page+len, "%-16s %d\n", "irq", card->irq);
1126 len += sprintf(page+len, "%-16s 0x%lx\n", "membase", card->membase);
1127 switch (card->cardtype) {
1128 case avm_b1isa: s = "B1 ISA"; break;
1129 case avm_b1pci: s = "B1 PCI"; break;
1130 case avm_b1pcmcia: s = "B1 PCMCIA"; break;
1131 case avm_m1: s = "M1"; break;
1132 case avm_m2: s = "M2"; break;
1133 case avm_t1isa: s = "T1 ISA (HEMA)"; break;
1134 case avm_t1pci: s = "T1 PCI"; break;
1135 case avm_c4: s = "C4"; break;
1136 default: s = "???"; break;
1137 }
1138 len += sprintf(page+len, "%-16s %s\n", "type", s);
1139 if ((s = cinfo->version[VER_DRIVER]) != 0)
1140 len += sprintf(page+len, "%-16s %s\n", "ver_driver", s);
1141 if ((s = cinfo->version[VER_CARDTYPE]) != 0)
1142 len += sprintf(page+len, "%-16s %s\n", "ver_cardtype", s);
1143 if ((s = cinfo->version[VER_SERIAL]) != 0)
1144 len += sprintf(page+len, "%-16s %s\n", "ver_serial", s);
1145
1146 if (card->cardtype != avm_m1) {
1147 flag = ((__u8 *)(ctrl->profile.manu))[3];
1148 if (flag)
1149 len += sprintf(page+len, "%-16s%s%s%s%s%s%s%s\n",
1150 "protocol",
1151 (flag & 0x01) ? " DSS1" : "",
1152 (flag & 0x02) ? " CT1" : "",
1153 (flag & 0x04) ? " VN3" : "",
1154 (flag & 0x08) ? " NI1" : "",
1155 (flag & 0x10) ? " AUSTEL" : "",
1156 (flag & 0x20) ? " ESS" : "",
1157 (flag & 0x40) ? " 1TR6" : ""
1158 );
1159 }
1160 if (card->cardtype != avm_m1) {
1161 flag = ((__u8 *)(ctrl->profile.manu))[5];
1162 if (flag)
1163 len += sprintf(page+len, "%-16s%s%s%s%s\n",
1164 "linetype",
1165 (flag & 0x01) ? " point to point" : "",
1166 (flag & 0x02) ? " point to multipoint" : "",
1167 (flag & 0x08) ? " leased line without D-channel" : "",
1168 (flag & 0x04) ? " leased line with D-channel" : ""
1169 );
1170 }
1171 len += sprintf(page+len, "%-16s %s\n", "cardname", cinfo->cardname);
1172
1173 if (off+count >= len)
1174 *eof = 1;
1175 if (len < off)
1176 return 0;
1177 *start = page + off;
1178 return ((count < len-off) ? count : len-off);
1179 }
1180
1181 /* ------------------------------------------------------------- */
1182
1183 static int c4_add_card(struct capi_driver *driver, struct capicardparams *p)
1184 {
1185 unsigned long base, page_offset;
1186 avmctrl_info *cinfo;
1187 avmcard *card;
1188 int retval;
1189 int i;
1190
1191 MOD_INC_USE_COUNT;
1192
1193 card = (avmcard *) kmalloc(sizeof(avmcard), GFP_ATOMIC);
1194
1195 if (!card) {
1196 printk(KERN_WARNING "%s: no memory.\n", driver->name);
1197 MOD_DEC_USE_COUNT;
1198 return -ENOMEM;
1199 }
1200 memset(card, 0, sizeof(avmcard));
1201 card->dma = (avmcard_dmainfo *) kmalloc(sizeof(avmcard_dmainfo), GFP_ATOMIC);
1202 if (!card->dma) {
1203 printk(KERN_WARNING "%s: no memory.\n", driver->name);
1204 kfree(card);
1205 MOD_DEC_USE_COUNT;
1206 return -ENOMEM;
1207 }
1208 memset(card->dma, 0, sizeof(avmcard_dmainfo));
1209 cinfo = (avmctrl_info *) kmalloc(sizeof(avmctrl_info)*4, GFP_ATOMIC);
1210 if (!cinfo) {
1211 printk(KERN_WARNING "%s: no memory.\n", driver->name);
1212 kfree(card->dma);
1213 kfree(card);
1214 MOD_DEC_USE_COUNT;
1215 return -ENOMEM;
1216 }
1217 memset(cinfo, 0, sizeof(avmctrl_info)*4);
1218 card->ctrlinfo = cinfo;
1219 for (i=0; i < 4; i++) {
1220 cinfo = &card->ctrlinfo[i];
1221 cinfo->card = card;
1222 }
1223 sprintf(card->name, "c4-%x", p->port);
1224 card->port = p->port;
1225 card->irq = p->irq;
1226 card->membase = p->membase;
1227 card->cardtype = avm_c4;
1228
1229 if (check_region(card->port, AVMB1_PORTLEN)) {
1230 printk(KERN_WARNING
1231 "%s: ports 0x%03x-0x%03x in use.\n",
1232 driver->name, card->port, card->port + AVMB1_PORTLEN);
1233 kfree(card->ctrlinfo);
1234 kfree(card->dma);
1235 kfree(card);
1236 MOD_DEC_USE_COUNT;
1237 return -EBUSY;
1238 }
1239
1240 base = card->membase & PAGE_MASK;
1241 page_offset = card->membase - base;
1242 card->mbase = ioremap_nocache(base, page_offset + 128);
1243 if (card->mbase) {
1244 card->mbase += page_offset;
1245 } else {
1246 printk(KERN_NOTICE "%s: can't remap memory at 0x%lx\n",
1247 driver->name, card->membase);
1248 kfree(card->ctrlinfo);
1249 kfree(card->dma);
1250 kfree(card);
1251 MOD_DEC_USE_COUNT;
1252 return -EIO;
1253 }
1254
1255 if ((retval = c4_detect(card)) != 0) {
1256 printk(KERN_NOTICE "%s: NO card at 0x%x (%d)\n",
1257 driver->name, card->port, retval);
1258 iounmap((void *) (((unsigned long) card->mbase) & PAGE_MASK));
1259 kfree(card->ctrlinfo);
1260 kfree(card->dma);
1261 kfree(card);
1262 MOD_DEC_USE_COUNT;
1263 return -EIO;
1264 }
1265 c4_reset(card);
1266
1267 request_region(p->port, AVMB1_PORTLEN, card->name);
1268
1269 retval = request_irq(card->irq, c4_interrupt, SA_SHIRQ, card->name, card);
1270 if (retval) {
1271 printk(KERN_ERR "%s: unable to get IRQ %d.\n",
1272 driver->name, card->irq);
1273 iounmap((void *) (((unsigned long) card->mbase) & PAGE_MASK));
1274 release_region(card->port, AVMB1_PORTLEN);
1275 kfree(card->ctrlinfo);
1276 kfree(card->dma);
1277 kfree(card);
1278 MOD_DEC_USE_COUNT;
1279 return -EBUSY;
1280 }
1281
1282 for (i=0; i < 4; i++) {
1283 cinfo = &card->ctrlinfo[i];
1284 cinfo->card = card;
1285 cinfo->capi_ctrl = di->attach_ctr(driver, card->name, cinfo);
1286 if (!cinfo->capi_ctrl) {
1287 printk(KERN_ERR "%s: attach controller failed (%d).\n",
1288 driver->name, i);
1289 for (i--; i >= 0; i--) {
1290 cinfo = &card->ctrlinfo[i];
1291 di->detach_ctr(cinfo->capi_ctrl);
1292 }
1293 iounmap((void *) (((unsigned long) card->mbase) & PAGE_MASK));
1294 free_irq(card->irq, card);
1295 release_region(card->port, AVMB1_PORTLEN);
1296 kfree(card->dma);
1297 kfree(card->ctrlinfo);
1298 kfree(card);
1299 MOD_DEC_USE_COUNT;
1300 return -EBUSY;
1301 }
1302 if (i == 0)
1303 card->cardnr = cinfo->capi_ctrl->cnr;
1304 }
1305
1306 skb_queue_head_init(&card->dma->send_queue);
1307
1308 printk(KERN_INFO
1309 "%s: AVM C4 at i/o %#x, irq %d, mem %#lx\n",
1310 driver->name, card->port, card->irq, card->membase);
1311
1312 return 0;
1313 }
1314
1315 /* ------------------------------------------------------------- */
1316
1317 static struct capi_driver c4_driver = {
1318 name: "c4",
1319 revision: "0.0",
1320 load_firmware: c4_load_firmware,
1321 reset_ctr: c4_reset_ctr,
1322 remove_ctr: c4_remove_ctr,
1323 register_appl: c4_register_appl,
1324 release_appl: c4_release_appl,
1325 send_message: c4_send_message,
1326
1327 procinfo: c4_procinfo,
1328 ctr_read_proc: c4_read_proc,
1329 driver_read_proc: 0, /* use standard driver_read_proc */
1330
1331 add_card: 0, /* no add_card function */
1332 };
1333
1334
1335 static int ncards = 0;
1336
1337 static int __init c4_init(void)
1338 {
1339 struct capi_driver *driver = &c4_driver;
1340 struct pci_dev *dev = NULL;
1341 char *p;
1342 int retval;
1343
1344 MOD_INC_USE_COUNT;
1345
1346 if ((p = strchr(revision, ':'))) {
1347 strncpy(driver->revision, p + 1, sizeof(driver->revision));
1348 p = strchr(driver->revision, '$');
1349 *p = 0;
1350 }
1351
1352 printk(KERN_INFO "%s: revision %s\n", driver->name, driver->revision);
1353
1354 di = attach_capi_driver(driver);
1355
1356 if (!di) {
1357 printk(KERN_ERR "%s: failed to attach capi_driver\n",
1358 driver->name);
1359 MOD_DEC_USE_COUNT;
1360 return -EIO;
1361 }
1362
1363 #ifdef CONFIG_PCI
1364 if (!pci_present()) {
1365 printk(KERN_ERR "%s: no PCI bus present\n", driver->name);
1366 detach_capi_driver(driver);
1367 MOD_DEC_USE_COUNT;
1368 return -EIO;
1369 }
1370
1371 while ((dev = pci_find_subsys(
1372 PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_21285,
1373 PCI_VENDOR_ID_AVM, PCI_DEVICE_ID_AVM_C4, dev))) {
1374 struct capicardparams param;
1375
1376 param.port = pci_resource_start(dev, 1);
1377 param.irq = dev->irq;
1378 param.membase = pci_resource_start(dev, 0);
1379
1380 retval = pci_enable_device (dev);
1381 if (retval != 0) {
1382 printk(KERN_ERR
1383 "%s: failed to enable AVM-C4 at i/o %#x, irq %d, mem %#x err=%d\n",
1384 driver->name, param.port, param.irq, param.membase, retval);
1385 detach_capi_driver(driver);
1386 MOD_DEC_USE_COUNT;
1387 return -EIO;
1388 }
1389
1390 printk(KERN_INFO
1391 "%s: PCI BIOS reports AVM-C4 at i/o %#x, irq %d, mem %#x\n",
1392 driver->name, param.port, param.irq, param.membase);
1393 retval = c4_add_card(driver, &param);
1394 if (retval != 0) {
1395 printk(KERN_ERR
1396 "%s: no AVM-C4 at i/o %#x, irq %d detected, mem %#x\n",
1397 driver->name, param.port, param.irq, param.membase);
1398 detach_capi_driver(driver);
1399 MOD_DEC_USE_COUNT;
1400 return retval;
1401 }
1402 ncards++;
1403 }
1404 if (ncards) {
1405 printk(KERN_INFO "%s: %d C4 card(s) detected\n",
1406 driver->name, ncards);
1407 MOD_DEC_USE_COUNT;
1408 return 0;
1409 }
1410 printk(KERN_ERR "%s: NO C4 card detected\n", driver->name);
1411 detach_capi_driver(driver);
1412 MOD_DEC_USE_COUNT;
1413 return -ESRCH;
1414 #else
1415 printk(KERN_ERR "%s: kernel not compiled with PCI.\n", driver->name);
1416 MOD_DEC_USE_COUNT;
1417 return -EIO;
1418 #endif
1419 }
1420
1421 static void __exit c4_exit(void)
1422 {
1423 detach_capi_driver(&c4_driver);
1424 }
1425
1426 module_init(c4_init);
1427 module_exit(c4_exit);
Copy of Dave Jones history.git as used by http://archive.org/details/git-history-of-linux