?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] fix semaphore handling in __unregister_chrdev_region
[linux/fpc-iii.git] / drivers / isdn / hisax / hisax_fcpcipnp.c
blobb4d795d40154232a217c86943f26281212ba0eee
1 /*
2 * Driver for AVM Fritz!PCI, Fritz!PCI v2, Fritz!PnP ISDN cards
3 *
4 * Author Kai Germaschewski
5 * Copyright 2001 by Kai Germaschewski <kai.germaschewski@gmx.de>
6 * 2001 by Karsten Keil <keil@isdn4linux.de>
7 *
8 * based upon Karsten Keil's original avm_pci.c driver
9 *
10 * This software may be used and distributed according to the terms
11 * of the GNU General Public License, incorporated herein by reference.
12 *
13 * Thanks to Wizard Computersysteme GmbH, Bremervoerde and
14 * SoHaNet Technology GmbH, Berlin
15 * for supporting the development of this driver
16 */
17
18
19 /* TODO:
20 *
21 * o POWER PC
22 * o clean up debugging
23 * o tx_skb at PH_DEACTIVATE time
24 */
25
26 #include <linux/version.h>
27 #include <linux/module.h>
28 #include <linux/init.h>
29 #include <linux/pci.h>
30 #include <linux/isapnp.h>
31 #include <linux/kmod.h>
32 #include <linux/slab.h>
33 #include <linux/skbuff.h>
34 #include <linux/netdevice.h>
35 #include <linux/delay.h>
36
37 #include <asm/io.h>
38
39 #include "hisax_fcpcipnp.h"
40
41 // debugging cruft
42 #define __debug_variable debug
43 #include "hisax_debug.h"
44
45 #ifdef CONFIG_HISAX_DEBUG
46 static int debug = 0;
47 /* static int hdlcfifosize = 32; */
48 module_param(debug, int, 0);
49 /* module_param(hdlcfifosize, int, 0); */
50 #endif
51
52 MODULE_AUTHOR("Kai Germaschewski <kai.germaschewski@gmx.de>/Karsten Keil <kkeil@suse.de>");
53 MODULE_DESCRIPTION("AVM Fritz!PCI/PnP ISDN driver");
54
55 static struct pci_device_id fcpci_ids[] = {
56 { .vendor = PCI_VENDOR_ID_AVM,
57 .device = PCI_DEVICE_ID_AVM_A1,
58 .subvendor = PCI_ANY_ID,
59 .subdevice = PCI_ANY_ID,
60 .driver_data = (unsigned long) "Fritz!Card PCI",
61 },
62 { .vendor = PCI_VENDOR_ID_AVM,
63 .device = PCI_DEVICE_ID_AVM_A1_V2,
64 .subvendor = PCI_ANY_ID,
65 .subdevice = PCI_ANY_ID,
66 .driver_data = (unsigned long) "Fritz!Card PCI v2" },
67 {}
68 };
69
70 MODULE_DEVICE_TABLE(pci, fcpci_ids);
71
72 #ifdef __ISAPNP__
73 static struct pnp_device_id fcpnp_ids[] __devinitdata = {
74 {
75 .id = "AVM0900",
76 .driver_data = (unsigned long) "Fritz!Card PnP",
77 },
78 };
79
80 MODULE_DEVICE_TABLE(isapnp, fcpnp_ids);
81 #endif
82
83 static int protocol = 2; /* EURO-ISDN Default */
84 module_param(protocol, int, 0);
85 MODULE_LICENSE("GPL");
86
87 // ----------------------------------------------------------------------
88
89 #define AVM_INDEX 0x04
90 #define AVM_DATA 0x10
91
92 #define AVM_IDX_HDLC_1 0x00
93 #define AVM_IDX_HDLC_2 0x01
94 #define AVM_IDX_ISAC_FIFO 0x02
95 #define AVM_IDX_ISAC_REG_LOW 0x04
96 #define AVM_IDX_ISAC_REG_HIGH 0x06
97
98 #define AVM_STATUS0 0x02
99
100 #define AVM_STATUS0_IRQ_ISAC 0x01
101 #define AVM_STATUS0_IRQ_HDLC 0x02
102 #define AVM_STATUS0_IRQ_TIMER 0x04
103 #define AVM_STATUS0_IRQ_MASK 0x07
104
105 #define AVM_STATUS0_RESET 0x01
106 #define AVM_STATUS0_DIS_TIMER 0x02
107 #define AVM_STATUS0_RES_TIMER 0x04
108 #define AVM_STATUS0_ENA_IRQ 0x08
109 #define AVM_STATUS0_TESTBIT 0x10
110
111 #define AVM_STATUS1 0x03
112 #define AVM_STATUS1_ENA_IOM 0x80
113
114 #define HDLC_FIFO 0x0
115 #define HDLC_STATUS 0x4
116 #define HDLC_CTRL 0x4
117
118 #define HDLC_MODE_ITF_FLG 0x01
119 #define HDLC_MODE_TRANS 0x02
120 #define HDLC_MODE_CCR_7 0x04
121 #define HDLC_MODE_CCR_16 0x08
122 #define HDLC_MODE_TESTLOOP 0x80
123
124 #define HDLC_INT_XPR 0x80
125 #define HDLC_INT_XDU 0x40
126 #define HDLC_INT_RPR 0x20
127 #define HDLC_INT_MASK 0xE0
128
129 #define HDLC_STAT_RME 0x01
130 #define HDLC_STAT_RDO 0x10
131 #define HDLC_STAT_CRCVFRRAB 0x0E
132 #define HDLC_STAT_CRCVFR 0x06
133 #define HDLC_STAT_RML_MASK 0xff00
134
135 #define HDLC_CMD_XRS 0x80
136 #define HDLC_CMD_XME 0x01
137 #define HDLC_CMD_RRS 0x20
138 #define HDLC_CMD_XML_MASK 0xff00
139
140 #define AVM_HDLC_FIFO_1 0x10
141 #define AVM_HDLC_FIFO_2 0x18
142
143 #define AVM_HDLC_STATUS_1 0x14
144 #define AVM_HDLC_STATUS_2 0x1c
145
146 #define AVM_ISACSX_INDEX 0x04
147 #define AVM_ISACSX_DATA 0x08
148
149 // ----------------------------------------------------------------------
150 // Fritz!PCI
151
152 static unsigned char fcpci_read_isac(struct isac *isac, unsigned char offset)
153 {
154 struct fritz_adapter *adapter = isac->priv;
155 unsigned char idx = (offset > 0x2f) ?
156 AVM_IDX_ISAC_REG_HIGH : AVM_IDX_ISAC_REG_LOW;
157 unsigned char val;
158 unsigned long flags;
159
160 spin_lock_irqsave(&adapter->hw_lock, flags);
161 outb(idx, adapter->io + AVM_INDEX);
162 val = inb(adapter->io + AVM_DATA + (offset & 0xf));
163 spin_unlock_irqrestore(&adapter->hw_lock, flags);
164 DBG(0x1000, " port %#x, value %#x",
165 offset, val);
166 return val;
167 }
168
169 static void fcpci_write_isac(struct isac *isac, unsigned char offset,
170 unsigned char value)
171 {
172 struct fritz_adapter *adapter = isac->priv;
173 unsigned char idx = (offset > 0x2f) ?
174 AVM_IDX_ISAC_REG_HIGH : AVM_IDX_ISAC_REG_LOW;
175 unsigned long flags;
176
177 DBG(0x1000, " port %#x, value %#x",
178 offset, value);
179 spin_lock_irqsave(&adapter->hw_lock, flags);
180 outb(idx, adapter->io + AVM_INDEX);
181 outb(value, adapter->io + AVM_DATA + (offset & 0xf));
182 spin_unlock_irqrestore(&adapter->hw_lock, flags);
183 }
184
185 static void fcpci_read_isac_fifo(struct isac *isac, unsigned char * data,
186 int size)
187 {
188 struct fritz_adapter *adapter = isac->priv;
189 unsigned long flags;
190
191 spin_lock_irqsave(&adapter->hw_lock, flags);
192 outb(AVM_IDX_ISAC_FIFO, adapter->io + AVM_INDEX);
193 insb(adapter->io + AVM_DATA, data, size);
194 spin_unlock_irqrestore(&adapter->hw_lock, flags);
195 }
196
197 static void fcpci_write_isac_fifo(struct isac *isac, unsigned char * data,
198 int size)
199 {
200 struct fritz_adapter *adapter = isac->priv;
201 unsigned long flags;
202
203 spin_lock_irqsave(&adapter->hw_lock, flags);
204 outb(AVM_IDX_ISAC_FIFO, adapter->io + AVM_INDEX);
205 outsb(adapter->io + AVM_DATA, data, size);
206 spin_unlock_irqrestore(&adapter->hw_lock, flags);
207 }
208
209 static u32 fcpci_read_hdlc_status(struct fritz_adapter *adapter, int nr)
210 {
211 u32 val;
212 int idx = nr ? AVM_IDX_HDLC_2 : AVM_IDX_HDLC_1;
213 unsigned long flags;
214
215 spin_lock_irqsave(&adapter->hw_lock, flags);
216 outl(idx, adapter->io + AVM_INDEX);
217 val = inl(adapter->io + AVM_DATA + HDLC_STATUS);
218 spin_unlock_irqrestore(&adapter->hw_lock, flags);
219 return val;
220 }
221
222 static void __fcpci_write_ctrl(struct fritz_bcs *bcs, int which)
223 {
224 struct fritz_adapter *adapter = bcs->adapter;
225 int idx = bcs->channel ? AVM_IDX_HDLC_2 : AVM_IDX_HDLC_1;
226
227 DBG(0x40, "hdlc %c wr%x ctrl %x",
228 'A' + bcs->channel, which, bcs->ctrl.ctrl);
229
230 outl(idx, adapter->io + AVM_INDEX);
231 outl(bcs->ctrl.ctrl, adapter->io + AVM_DATA + HDLC_CTRL);
232 }
233
234 static void fcpci_write_ctrl(struct fritz_bcs *bcs, int which)
235 {
236 struct fritz_adapter *adapter = bcs->adapter;
237 unsigned long flags;
238
239 spin_lock_irqsave(&adapter->hw_lock, flags);
240 __fcpci_write_ctrl(bcs, which);
241 spin_unlock_irqrestore(&adapter->hw_lock, flags);
242 }
243
244 // ----------------------------------------------------------------------
245 // Fritz!PCI v2
246
247 static unsigned char fcpci2_read_isac(struct isac *isac, unsigned char offset)
248 {
249 struct fritz_adapter *adapter = isac->priv;
250 unsigned char val;
251 unsigned long flags;
252
253 spin_lock_irqsave(&adapter->hw_lock, flags);
254 outl(offset, adapter->io + AVM_ISACSX_INDEX);
255 val = inl(adapter->io + AVM_ISACSX_DATA);
256 spin_unlock_irqrestore(&adapter->hw_lock, flags);
257 DBG(0x1000, " port %#x, value %#x",
258 offset, val);
259
260 return val;
261 }
262
263 static void fcpci2_write_isac(struct isac *isac, unsigned char offset,
264 unsigned char value)
265 {
266 struct fritz_adapter *adapter = isac->priv;
267 unsigned long flags;
268
269 DBG(0x1000, " port %#x, value %#x",
270 offset, value);
271 spin_lock_irqsave(&adapter->hw_lock, flags);
272 outl(offset, adapter->io + AVM_ISACSX_INDEX);
273 outl(value, adapter->io + AVM_ISACSX_DATA);
274 spin_unlock_irqrestore(&adapter->hw_lock, flags);
275 }
276
277 static void fcpci2_read_isac_fifo(struct isac *isac, unsigned char * data,
278 int size)
279 {
280 struct fritz_adapter *adapter = isac->priv;
281 int i;
282 unsigned long flags;
283
284 spin_lock_irqsave(&adapter->hw_lock, flags);
285 outl(0, adapter->io + AVM_ISACSX_INDEX);
286 for (i = 0; i < size; i++)
287 data[i] = inl(adapter->io + AVM_ISACSX_DATA);
288 spin_unlock_irqrestore(&adapter->hw_lock, flags);
289 }
290
291 static void fcpci2_write_isac_fifo(struct isac *isac, unsigned char * data,
292 int size)
293 {
294 struct fritz_adapter *adapter = isac->priv;
295 int i;
296 unsigned long flags;
297
298 spin_lock_irqsave(&adapter->hw_lock, flags);
299 outl(0, adapter->io + AVM_ISACSX_INDEX);
300 for (i = 0; i < size; i++)
301 outl(data[i], adapter->io + AVM_ISACSX_DATA);
302 spin_unlock_irqrestore(&adapter->hw_lock, flags);
303 }
304
305 static u32 fcpci2_read_hdlc_status(struct fritz_adapter *adapter, int nr)
306 {
307 int offset = nr ? AVM_HDLC_STATUS_2 : AVM_HDLC_STATUS_1;
308
309 return inl(adapter->io + offset);
310 }
311
312 static void fcpci2_write_ctrl(struct fritz_bcs *bcs, int which)
313 {
314 struct fritz_adapter *adapter = bcs->adapter;
315 int offset = bcs->channel ? AVM_HDLC_STATUS_2 : AVM_HDLC_STATUS_1;
316
317 DBG(0x40, "hdlc %c wr%x ctrl %x",
318 'A' + bcs->channel, which, bcs->ctrl.ctrl);
319
320 outl(bcs->ctrl.ctrl, adapter->io + offset);
321 }
322
323 // ----------------------------------------------------------------------
324 // Fritz!PnP (ISAC access as for Fritz!PCI)
325
326 static u32 fcpnp_read_hdlc_status(struct fritz_adapter *adapter, int nr)
327 {
328 unsigned char idx = nr ? AVM_IDX_HDLC_2 : AVM_IDX_HDLC_1;
329 u32 val;
330 unsigned long flags;
331
332 spin_lock_irqsave(&adapter->hw_lock, flags);
333 outb(idx, adapter->io + AVM_INDEX);
334 val = inb(adapter->io + AVM_DATA + HDLC_STATUS);
335 if (val & HDLC_INT_RPR)
336 val |= inb(adapter->io + AVM_DATA + HDLC_STATUS + 1) << 8;
337 spin_unlock_irqrestore(&adapter->hw_lock, flags);
338 return val;
339 }
340
341 static void __fcpnp_write_ctrl(struct fritz_bcs *bcs, int which)
342 {
343 struct fritz_adapter *adapter = bcs->adapter;
344 unsigned char idx = bcs->channel ? AVM_IDX_HDLC_2 : AVM_IDX_HDLC_1;
345
346 DBG(0x40, "hdlc %c wr%x ctrl %x",
347 'A' + bcs->channel, which, bcs->ctrl.ctrl);
348
349 outb(idx, adapter->io + AVM_INDEX);
350 if (which & 4)
351 outb(bcs->ctrl.sr.mode,
352 adapter->io + AVM_DATA + HDLC_STATUS + 2);
353 if (which & 2)
354 outb(bcs->ctrl.sr.xml,
355 adapter->io + AVM_DATA + HDLC_STATUS + 1);
356 if (which & 1)
357 outb(bcs->ctrl.sr.cmd,
358 adapter->io + AVM_DATA + HDLC_STATUS + 0);
359 }
360
361 static void fcpnp_write_ctrl(struct fritz_bcs *bcs, int which)
362 {
363 struct fritz_adapter *adapter = bcs->adapter;
364 unsigned long flags;
365
366 spin_lock_irqsave(&adapter->hw_lock, flags);
367 __fcpnp_write_ctrl(bcs, which);
368 spin_unlock_irqrestore(&adapter->hw_lock, flags);
369 }
370
371 // ----------------------------------------------------------------------
372
373 static inline void B_L1L2(struct fritz_bcs *bcs, int pr, void *arg)
374 {
375 struct hisax_if *ifc = (struct hisax_if *) &bcs->b_if;
376
377 DBG(2, "pr %#x", pr);
378 ifc->l1l2(ifc, pr, arg);
379 }
380
381 static void hdlc_fill_fifo(struct fritz_bcs *bcs)
382 {
383 struct fritz_adapter *adapter = bcs->adapter;
384 struct sk_buff *skb = bcs->tx_skb;
385 int count;
386 unsigned long flags;
387 unsigned char *p;
388
389 DBG(0x40, "hdlc_fill_fifo");
390
391 if (skb->len == 0)
392 BUG();
393
394 bcs->ctrl.sr.cmd &= ~HDLC_CMD_XME;
395 if (bcs->tx_skb->len > bcs->fifo_size) {
396 count = bcs->fifo_size;
397 } else {
398 count = bcs->tx_skb->len;
399 if (bcs->mode != L1_MODE_TRANS)
400 bcs->ctrl.sr.cmd |= HDLC_CMD_XME;
401 }
402 DBG(0x40, "hdlc_fill_fifo %d/%d", count, bcs->tx_skb->len);
403 p = bcs->tx_skb->data;
404 skb_pull(bcs->tx_skb, count);
405 bcs->tx_cnt += count;
406 bcs->ctrl.sr.xml = ((count == bcs->fifo_size) ? 0 : count);
407
408 switch (adapter->type) {
409 case AVM_FRITZ_PCI:
410 spin_lock_irqsave(&adapter->hw_lock, flags);
411 // sets the correct AVM_INDEX, too
412 __fcpci_write_ctrl(bcs, 3);
413 outsl(adapter->io + AVM_DATA + HDLC_FIFO,
414 p, (count + 3) / 4);
415 spin_unlock_irqrestore(&adapter->hw_lock, flags);
416 break;
417 case AVM_FRITZ_PCIV2:
418 fcpci2_write_ctrl(bcs, 3);
419 outsl(adapter->io +
420 (bcs->channel ? AVM_HDLC_FIFO_2 : AVM_HDLC_FIFO_1),
421 p, (count + 3) / 4);
422 break;
423 case AVM_FRITZ_PNP:
424 spin_lock_irqsave(&adapter->hw_lock, flags);
425 // sets the correct AVM_INDEX, too
426 __fcpnp_write_ctrl(bcs, 3);
427 outsb(adapter->io + AVM_DATA, p, count);
428 spin_unlock_irqrestore(&adapter->hw_lock, flags);
429 break;
430 }
431 }
432
433 static inline void hdlc_empty_fifo(struct fritz_bcs *bcs, int count)
434 {
435 struct fritz_adapter *adapter = bcs->adapter;
436 unsigned char *p;
437 unsigned char idx = bcs->channel ? AVM_IDX_HDLC_2 : AVM_IDX_HDLC_1;
438
439 DBG(0x10, "hdlc_empty_fifo %d", count);
440 if (bcs->rcvidx + count > HSCX_BUFMAX) {
441 DBG(0x10, "hdlc_empty_fifo: incoming packet too large");
442 return;
443 }
444 p = bcs->rcvbuf + bcs->rcvidx;
445 bcs->rcvidx += count;
446 switch (adapter->type) {
447 case AVM_FRITZ_PCI:
448 spin_lock(&adapter->hw_lock);
449 outl(idx, adapter->io + AVM_INDEX);
450 insl(adapter->io + AVM_DATA + HDLC_FIFO,
451 p, (count + 3) / 4);
452 spin_unlock(&adapter->hw_lock);
453 break;
454 case AVM_FRITZ_PCIV2:
455 insl(adapter->io +
456 (bcs->channel ? AVM_HDLC_FIFO_2 : AVM_HDLC_FIFO_1),
457 p, (count + 3) / 4);
458 break;
459 case AVM_FRITZ_PNP:
460 spin_lock(&adapter->hw_lock);
461 outb(idx, adapter->io + AVM_INDEX);
462 insb(adapter->io + AVM_DATA, p, count);
463 spin_unlock(&adapter->hw_lock);
464 break;
465 }
466 }
467
468 static inline void hdlc_rpr_irq(struct fritz_bcs *bcs, u32 stat)
469 {
470 struct fritz_adapter *adapter = bcs->adapter;
471 struct sk_buff *skb;
472 int len;
473
474 if (stat & HDLC_STAT_RDO) {
475 DBG(0x10, "RDO");
476 bcs->ctrl.sr.xml = 0;
477 bcs->ctrl.sr.cmd |= HDLC_CMD_RRS;
478 adapter->write_ctrl(bcs, 1);
479 bcs->ctrl.sr.cmd &= ~HDLC_CMD_RRS;
480 adapter->write_ctrl(bcs, 1);
481 bcs->rcvidx = 0;
482 return;
483 }
484
485 len = (stat & HDLC_STAT_RML_MASK) >> 8;
486 if (len == 0)
487 len = bcs->fifo_size;
488
489 hdlc_empty_fifo(bcs, len);
490
491 if ((stat & HDLC_STAT_RME) || (bcs->mode == L1_MODE_TRANS)) {
492 if (((stat & HDLC_STAT_CRCVFRRAB)== HDLC_STAT_CRCVFR) ||
493 (bcs->mode == L1_MODE_TRANS)) {
494 skb = dev_alloc_skb(bcs->rcvidx);
495 if (!skb) {
496 printk(KERN_WARNING "HDLC: receive out of memory\n");
497 } else {
498 memcpy(skb_put(skb, bcs->rcvidx), bcs->rcvbuf,
499 bcs->rcvidx);
500 DBG_SKB(1, skb);
501 B_L1L2(bcs, PH_DATA | INDICATION, skb);
502 }
503 bcs->rcvidx = 0;
504 } else {
505 DBG(0x10, "ch%d invalid frame %#x",
506 bcs->channel, stat);
507 bcs->rcvidx = 0;
508 }
509 }
510 }
511
512 static inline void hdlc_xdu_irq(struct fritz_bcs *bcs)
513 {
514 struct fritz_adapter *adapter = bcs->adapter;
515
516
517 /* Here we lost an TX interrupt, so
518 * restart transmitting the whole frame.
519 */
520 bcs->ctrl.sr.xml = 0;
521 bcs->ctrl.sr.cmd |= HDLC_CMD_XRS;
522 adapter->write_ctrl(bcs, 1);
523 bcs->ctrl.sr.cmd &= ~HDLC_CMD_XRS;
524
525 if (!bcs->tx_skb) {
526 DBG(0x10, "XDU without skb");
527 adapter->write_ctrl(bcs, 1);
528 return;
529 }
530 /* only hdlc restarts the frame, transparent mode must continue */
531 if (bcs->mode == L1_MODE_HDLC) {
532 skb_push(bcs->tx_skb, bcs->tx_cnt);
533 bcs->tx_cnt = 0;
534 }
535 }
536
537 static inline void hdlc_xpr_irq(struct fritz_bcs *bcs)
538 {
539 struct sk_buff *skb;
540
541 skb = bcs->tx_skb;
542 if (!skb)
543 return;
544
545 if (skb->len) {
546 hdlc_fill_fifo(bcs);
547 return;
548 }
549 bcs->tx_cnt = 0;
550 bcs->tx_skb = NULL;
551 B_L1L2(bcs, PH_DATA | CONFIRM, (void *) skb->truesize);
552 dev_kfree_skb_irq(skb);
553 }
554
555 static void hdlc_irq_one(struct fritz_bcs *bcs, u32 stat)
556 {
557 DBG(0x10, "ch%d stat %#x", bcs->channel, stat);
558 if (stat & HDLC_INT_RPR) {
559 DBG(0x10, "RPR");
560 hdlc_rpr_irq(bcs, stat);
561 }
562 if (stat & HDLC_INT_XDU) {
563 DBG(0x10, "XDU");
564 hdlc_xdu_irq(bcs);
565 hdlc_xpr_irq(bcs);
566 return;
567 }
568 if (stat & HDLC_INT_XPR) {
569 DBG(0x10, "XPR");
570 hdlc_xpr_irq(bcs);
571 }
572 }
573
574 static inline void hdlc_irq(struct fritz_adapter *adapter)
575 {
576 int nr;
577 u32 stat;
578
579 for (nr = 0; nr < 2; nr++) {
580 stat = adapter->read_hdlc_status(adapter, nr);
581 DBG(0x10, "HDLC %c stat %#x", 'A' + nr, stat);
582 if (stat & HDLC_INT_MASK)
583 hdlc_irq_one(&adapter->bcs[nr], stat);
584 }
585 }
586
587 static void modehdlc(struct fritz_bcs *bcs, int mode)
588 {
589 struct fritz_adapter *adapter = bcs->adapter;
590
591 DBG(0x40, "hdlc %c mode %d --> %d",
592 'A' + bcs->channel, bcs->mode, mode);
593
594 if (bcs->mode == mode)
595 return;
596
597 bcs->fifo_size = 32;
598 bcs->ctrl.ctrl = 0;
599 bcs->ctrl.sr.cmd = HDLC_CMD_XRS | HDLC_CMD_RRS;
600 switch (mode) {
601 case L1_MODE_NULL:
602 bcs->ctrl.sr.mode = HDLC_MODE_TRANS;
603 adapter->write_ctrl(bcs, 5);
604 break;
605 case L1_MODE_TRANS:
606 case L1_MODE_HDLC:
607 bcs->rcvidx = 0;
608 bcs->tx_cnt = 0;
609 bcs->tx_skb = NULL;
610 if (mode == L1_MODE_TRANS) {
611 bcs->ctrl.sr.mode = HDLC_MODE_TRANS;
612 } else {
613 bcs->ctrl.sr.mode = HDLC_MODE_ITF_FLG;
614 }
615 adapter->write_ctrl(bcs, 5);
616 bcs->ctrl.sr.cmd = HDLC_CMD_XRS;
617 adapter->write_ctrl(bcs, 1);
618 bcs->ctrl.sr.cmd = 0;
619 break;
620 }
621 bcs->mode = mode;
622 }
623
624 static void fritz_b_l2l1(struct hisax_if *ifc, int pr, void *arg)
625 {
626 struct fritz_bcs *bcs = ifc->priv;
627 struct sk_buff *skb = arg;
628 int mode;
629
630 DBG(0x10, "pr %#x", pr);
631
632 switch (pr) {
633 case PH_DATA | REQUEST:
634 if (bcs->tx_skb)
635 BUG();
636
637 bcs->tx_skb = skb;
638 DBG_SKB(1, skb);
639 hdlc_fill_fifo(bcs);
640 break;
641 case PH_ACTIVATE | REQUEST:
642 mode = (int) arg;
643 DBG(4,"B%d,PH_ACTIVATE_REQUEST %d", bcs->channel + 1, mode);
644 modehdlc(bcs, mode);
645 B_L1L2(bcs, PH_ACTIVATE | INDICATION, NULL);
646 break;
647 case PH_DEACTIVATE | REQUEST:
648 DBG(4,"B%d,PH_DEACTIVATE_REQUEST", bcs->channel + 1);
649 modehdlc(bcs, L1_MODE_NULL);
650 B_L1L2(bcs, PH_DEACTIVATE | INDICATION, NULL);
651 break;
652 }
653 }
654
655 // ----------------------------------------------------------------------
656
657 static irqreturn_t
658 fcpci2_irq(int intno, void *dev, struct pt_regs *regs)
659 {
660 struct fritz_adapter *adapter = dev;
661 unsigned char val;
662
663 val = inb(adapter->io + AVM_STATUS0);
664 if (!(val & AVM_STATUS0_IRQ_MASK))
665 /* hopefully a shared IRQ reqest */
666 return IRQ_NONE;
667 DBG(2, "STATUS0 %#x", val);
668 if (val & AVM_STATUS0_IRQ_ISAC)
669 isacsx_irq(&adapter->isac);
670 if (val & AVM_STATUS0_IRQ_HDLC)
671 hdlc_irq(adapter);
672 if (val & AVM_STATUS0_IRQ_ISAC)
673 isacsx_irq(&adapter->isac);
674 return IRQ_HANDLED;
675 }
676
677 static irqreturn_t
678 fcpci_irq(int intno, void *dev, struct pt_regs *regs)
679 {
680 struct fritz_adapter *adapter = dev;
681 unsigned char sval;
682
683 sval = inb(adapter->io + 2);
684 if ((sval & AVM_STATUS0_IRQ_MASK) == AVM_STATUS0_IRQ_MASK)
685 /* possibly a shared IRQ reqest */
686 return IRQ_NONE;
687 DBG(2, "sval %#x", sval);
688 if (!(sval & AVM_STATUS0_IRQ_ISAC))
689 isac_irq(&adapter->isac);
690
691 if (!(sval & AVM_STATUS0_IRQ_HDLC))
692 hdlc_irq(adapter);
693 return IRQ_HANDLED;
694 }
695
696 // ----------------------------------------------------------------------
697
698 static inline void fcpci2_init(struct fritz_adapter *adapter)
699 {
700 outb(AVM_STATUS0_RES_TIMER, adapter->io + AVM_STATUS0);
701 outb(AVM_STATUS0_ENA_IRQ, adapter->io + AVM_STATUS0);
702
703 }
704
705 static inline void fcpci_init(struct fritz_adapter *adapter)
706 {
707 outb(AVM_STATUS0_DIS_TIMER | AVM_STATUS0_RES_TIMER |
708 AVM_STATUS0_ENA_IRQ, adapter->io + AVM_STATUS0);
709
710 outb(AVM_STATUS1_ENA_IOM | adapter->irq,
711 adapter->io + AVM_STATUS1);
712 mdelay(10);
713 }
714
715 // ----------------------------------------------------------------------
716
717 static int __devinit fcpcipnp_setup(struct fritz_adapter *adapter)
718 {
719 u32 val = 0;
720 int retval;
721
722 DBG(1,"");
723
724 isac_init(&adapter->isac); // FIXME is this okay now
725
726 retval = -EBUSY;
727 if (!request_region(adapter->io, 32, "fcpcipnp"))
728 goto err;
729
730 switch (adapter->type) {
731 case AVM_FRITZ_PCIV2:
732 retval = request_irq(adapter->irq, fcpci2_irq, SA_SHIRQ,
733 "fcpcipnp", adapter);
734 break;
735 case AVM_FRITZ_PCI:
736 retval = request_irq(adapter->irq, fcpci_irq, SA_SHIRQ,
737 "fcpcipnp", adapter);
738 break;
739 case AVM_FRITZ_PNP:
740 retval = request_irq(adapter->irq, fcpci_irq, 0,
741 "fcpcipnp", adapter);
742 break;
743 }
744 if (retval)
745 goto err_region;
746
747 switch (adapter->type) {
748 case AVM_FRITZ_PCIV2:
749 case AVM_FRITZ_PCI:
750 val = inl(adapter->io);
751 break;
752 case AVM_FRITZ_PNP:
753 val = inb(adapter->io);
754 val |= inb(adapter->io + 1) << 8;
755 break;
756 }
757
758 DBG(1, "stat %#x Class %X Rev %d",
759 val, val & 0xff, (val>>8) & 0xff);
760
761 spin_lock_init(&adapter->hw_lock);
762 adapter->isac.priv = adapter;
763 switch (adapter->type) {
764 case AVM_FRITZ_PCIV2:
765 adapter->isac.read_isac = &fcpci2_read_isac;
766 adapter->isac.write_isac = &fcpci2_write_isac;
767 adapter->isac.read_isac_fifo = &fcpci2_read_isac_fifo;
768 adapter->isac.write_isac_fifo = &fcpci2_write_isac_fifo;
769
770 adapter->read_hdlc_status = &fcpci2_read_hdlc_status;
771 adapter->write_ctrl = &fcpci2_write_ctrl;
772 break;
773 case AVM_FRITZ_PCI:
774 adapter->isac.read_isac = &fcpci_read_isac;
775 adapter->isac.write_isac = &fcpci_write_isac;
776 adapter->isac.read_isac_fifo = &fcpci_read_isac_fifo;
777 adapter->isac.write_isac_fifo = &fcpci_write_isac_fifo;
778
779 adapter->read_hdlc_status = &fcpci_read_hdlc_status;
780 adapter->write_ctrl = &fcpci_write_ctrl;
781 break;
782 case AVM_FRITZ_PNP:
783 adapter->isac.read_isac = &fcpci_read_isac;
784 adapter->isac.write_isac = &fcpci_write_isac;
785 adapter->isac.read_isac_fifo = &fcpci_read_isac_fifo;
786 adapter->isac.write_isac_fifo = &fcpci_write_isac_fifo;
787
788 adapter->read_hdlc_status = &fcpnp_read_hdlc_status;
789 adapter->write_ctrl = &fcpnp_write_ctrl;
790 break;
791 }
792
793 // Reset
794 outb(0, adapter->io + AVM_STATUS0);
795 mdelay(10);
796 outb(AVM_STATUS0_RESET, adapter->io + AVM_STATUS0);
797 mdelay(10);
798 outb(0, adapter->io + AVM_STATUS0);
799 mdelay(10);
800
801 switch (adapter->type) {
802 case AVM_FRITZ_PCIV2:
803 fcpci2_init(adapter);
804 isacsx_setup(&adapter->isac);
805 break;
806 case AVM_FRITZ_PCI:
807 case AVM_FRITZ_PNP:
808 fcpci_init(adapter);
809 isac_setup(&adapter->isac);
810 break;
811 }
812 val = adapter->read_hdlc_status(adapter, 0);
813 DBG(0x20, "HDLC A STA %x", val);
814 val = adapter->read_hdlc_status(adapter, 1);
815 DBG(0x20, "HDLC B STA %x", val);
816
817 adapter->bcs[0].mode = -1;
818 adapter->bcs[1].mode = -1;
819 modehdlc(&adapter->bcs[0], L1_MODE_NULL);
820 modehdlc(&adapter->bcs[1], L1_MODE_NULL);
821
822 return 0;
823
824 err_region:
825 release_region(adapter->io, 32);
826 err:
827 return retval;
828 }
829
830 static void __devexit fcpcipnp_release(struct fritz_adapter *adapter)
831 {
832 DBG(1,"");
833
834 outb(0, adapter->io + AVM_STATUS0);
835 free_irq(adapter->irq, adapter);
836 release_region(adapter->io, 32);
837 }
838
839 // ----------------------------------------------------------------------
840
841 static struct fritz_adapter * __devinit
842 new_adapter(void)
843 {
844 struct fritz_adapter *adapter;
845 struct hisax_b_if *b_if[2];
846 int i;
847
848 adapter = kmalloc(sizeof(struct fritz_adapter), GFP_KERNEL);
849 if (!adapter)
850 return NULL;
851
852 memset(adapter, 0, sizeof(struct fritz_adapter));
853
854 adapter->isac.hisax_d_if.owner = THIS_MODULE;
855 adapter->isac.hisax_d_if.ifc.priv = &adapter->isac;
856 adapter->isac.hisax_d_if.ifc.l2l1 = isac_d_l2l1;
857
858 for (i = 0; i < 2; i++) {
859 adapter->bcs[i].adapter = adapter;
860 adapter->bcs[i].channel = i;
861 adapter->bcs[i].b_if.ifc.priv = &adapter->bcs[i];
862 adapter->bcs[i].b_if.ifc.l2l1 = fritz_b_l2l1;
863 }
864
865 for (i = 0; i < 2; i++)
866 b_if[i] = &adapter->bcs[i].b_if;
867
868 hisax_register(&adapter->isac.hisax_d_if, b_if, "fcpcipnp", protocol);
869
870 return adapter;
871 }
872
873 static void delete_adapter(struct fritz_adapter *adapter)
874 {
875 hisax_unregister(&adapter->isac.hisax_d_if);
876 kfree(adapter);
877 }
878
879 static int __devinit fcpci_probe(struct pci_dev *pdev,
880 const struct pci_device_id *ent)
881 {
882 struct fritz_adapter *adapter;
883 int retval;
884
885 retval = -ENOMEM;
886 adapter = new_adapter();
887 if (!adapter)
888 goto err;
889
890 pci_set_drvdata(pdev, adapter);
891
892 if (pdev->device == PCI_DEVICE_ID_AVM_A1_V2)
893 adapter->type = AVM_FRITZ_PCIV2;
894 else
895 adapter->type = AVM_FRITZ_PCI;
896
897 retval = pci_enable_device(pdev);
898 if (retval)
899 goto err_free;
900
901 adapter->io = pci_resource_start(pdev, 1);
902 adapter->irq = pdev->irq;
903
904 printk(KERN_INFO "hisax_fcpcipnp: found adapter %s at %s\n",
905 (char *) ent->driver_data, pci_name(pdev));
906
907 retval = fcpcipnp_setup(adapter);
908 if (retval)
909 goto err_free;
910
911 return 0;
912
913 err_free:
914 delete_adapter(adapter);
915 err:
916 return retval;
917 }
918
919 #ifdef __ISAPNP__
920 static int __devinit fcpnp_probe(struct pnp_dev *pdev, const struct pnp_device_id *dev_id)
921 {
922 struct fritz_adapter *adapter;
923 int retval;
924
925 if (!pdev)
926 return(-ENODEV);
927
928 retval = -ENOMEM;
929 adapter = new_adapter();
930 if (!adapter)
931 goto err;
932
933 pnp_set_drvdata(pdev, adapter);
934
935 adapter->type = AVM_FRITZ_PNP;
936
937 pnp_disable_dev(pdev);
938 retval = pnp_activate_dev(pdev);
939 if (retval < 0) {
940 printk(KERN_WARNING "%s: pnp_activate_dev(%s) ret(%d)\n", __FUNCTION__,
941 (char *)dev_id->driver_data, retval);
942 goto err_free;
943 }
944 adapter->io = pnp_port_start(pdev, 0);
945 adapter->irq = pnp_irq(pdev, 0);
946
947 printk(KERN_INFO "hisax_fcpcipnp: found adapter %s at IO %#x irq %d\n",
948 (char *) dev_id->driver_data, adapter->io, adapter->irq);
949
950 retval = fcpcipnp_setup(adapter);
951 if (retval)
952 goto err_free;
953
954 return 0;
955
956 err_free:
957 delete_adapter(adapter);
958 err:
959 return retval;
960 }
961
962 static void __devexit fcpnp_remove(struct pnp_dev *pdev)
963 {
964 struct fritz_adapter *adapter = pnp_get_drvdata(pdev);
965
966 if (adapter) {
967 fcpcipnp_release(adapter);
968 delete_adapter(adapter);
969 }
970 pnp_disable_dev(pdev);
971 }
972
973 static struct pnp_driver fcpnp_driver = {
974 .name = "fcpnp",
975 .probe = fcpnp_probe,
976 .remove = __devexit_p(fcpnp_remove),
977 .id_table = fcpnp_ids,
978 };
979 #endif
980
981 static void __devexit fcpci_remove(struct pci_dev *pdev)
982 {
983 struct fritz_adapter *adapter = pci_get_drvdata(pdev);
984
985 fcpcipnp_release(adapter);
986 pci_disable_device(pdev);
987 delete_adapter(adapter);
988 }
989
990 static struct pci_driver fcpci_driver = {
991 .name = "fcpci",
992 .probe = fcpci_probe,
993 .remove = __devexit_p(fcpci_remove),
994 .id_table = fcpci_ids,
995 };
996
997 static int __init hisax_fcpcipnp_init(void)
998 {
999 int retval;
1000
1001 printk(KERN_INFO "hisax_fcpcipnp: Fritz!Card PCI/PCIv2/PnP ISDN driver v0.0.1\n");
1002
1003 retval = pci_register_driver(&fcpci_driver);
1004 if (retval)
1005 goto out;
1006 #ifdef __ISAPNP__
1007 retval = pnp_register_driver(&fcpnp_driver);
1008 if (retval < 0)
1009 goto out_unregister_pci;
1010 #endif
1011 return 0;
1012
1013 out_unregister_pci:
1014 pci_unregister_driver(&fcpci_driver);
1015 out:
1016 return retval;
1017 }
1018
1019 static void __exit hisax_fcpcipnp_exit(void)
1020 {
1021 #ifdef __ISAPNP__
1022 pnp_unregister_driver(&fcpnp_driver);
1023 #endif
1024 pci_unregister_driver(&fcpci_driver);
1025 }
1026
1027 module_init(hisax_fcpcipnp_init);
1028 module_exit(hisax_fcpcipnp_exit);
Linux with added FPC-III support