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