d852c9d998b2bd51ae022bf870b5062298b3615c
[linux-3.10.git] / drivers / isdn / hisax / hfc4s8s_l1.c
1 /*************************************************************************/
2 /* $Id: hfc4s8s_l1.c,v 1.10 2005/02/09 16:31:09 martinb1 Exp $           */
3 /* HFC-4S/8S low layer interface for Cologne Chip HFC-4S/8S isdn chips   */
4 /* The low layer (L1) is implemented as a loadable module for usage with */
5 /* the HiSax isdn driver for passive cards.                              */
6 /*                                                                       */
7 /* Author: Werner Cornelius                                              */
8 /* (C) 2003 Cornelius Consult (werner@cornelius-consult.de)              */
9 /*                                                                       */
10 /* Driver maintained by Cologne Chip                                     */
11 /*   - Martin Bachem, support@colognechip.com                            */
12 /*                                                                       */
13 /* This driver only works with chip revisions >= 1, older revision 0     */
14 /* engineering samples (only first manufacturer sample cards) will not   */
15 /* work and are rejected by the driver.                                  */
16 /*                                                                       */
17 /* This file distributed under the GNU GPL.                              */
18 /*                                                                       */
19 /* See Version History at the end of this file                           */
20 /*                                                                       */
21 /*************************************************************************/
22
23 #include <linux/module.h>
24 #include <linux/init.h>
25 #include <linux/pci.h>
26 #include <linux/interrupt.h>
27 #include <linux/delay.h>
28 #include <linux/timer.h>
29 #include <linux/skbuff.h>
30 #include <linux/wait.h>
31 #include <asm/io.h>
32 #include "hisax_if.h"
33 #include "hfc4s8s_l1.h"
34
35 static const char hfc4s8s_rev[] = "Revision: 1.10";
36
37 /***************************************************************/
38 /* adjustable transparent mode fifo threshold                  */
39 /* The value defines the used fifo threshold with the equation */
40 /*                                                             */
41 /* notify number of bytes = 2 * 2 ^ TRANS_FIFO_THRES           */
42 /*                                                             */
43 /* The default value is 5 which results in a buffer size of 64 */
44 /* and an interrupt rate of 8ms.                               */
45 /* The maximum value is 7 due to fifo size restrictions.       */
46 /* Values below 3-4 are not recommended due to high interrupt  */
47 /* load of the processor. For non critical applications the    */
48 /* value should be raised to 7 to reduce any interrupt overhead*/
49 /***************************************************************/
50 #define TRANS_FIFO_THRES 5
51
52 /*************/
53 /* constants */
54 /*************/
55 #define CLOCKMODE_0     0       /* ext. 24.576 MhZ clk freq, int. single clock mode */
56 #define CLOCKMODE_1     1       /* ext. 49.576 MhZ clk freq, int. single clock mode */
57 #define CHIP_ID_SHIFT   4
58 #define HFC_MAX_ST 8
59 #define MAX_D_FRAME_SIZE 270
60 #define MAX_B_FRAME_SIZE 1536
61 #define TRANS_TIMER_MODE (TRANS_FIFO_THRES & 0xf)
62 #define TRANS_FIFO_BYTES (2 << TRANS_FIFO_THRES)
63 #define MAX_F_CNT 0x0f
64
65 #define CLKDEL_NT 0x6c
66 #define CLKDEL_TE 0xf
67 #define CTRL0_NT  4
68 #define CTRL0_TE  0
69
70 #define L1_TIMER_T4 2           /* minimum in jiffies */
71 #define L1_TIMER_T3 (7 * HZ)    /* activation timeout */
72 #define L1_TIMER_T1 ((120 * HZ) / 1000) /* NT mode deactivation timeout */
73
74
75 /******************/
76 /* types and vars */
77 /******************/
78 static int card_cnt;
79
80 /* private driver_data */
81 typedef struct {
82         int chip_id;
83         int clock_mode;
84         int max_st_ports;
85         char *device_name;
86 } hfc4s8s_param;
87
88 static struct pci_device_id hfc4s8s_ids[] = {
89         {.vendor = PCI_VENDOR_ID_CCD,
90          .device = PCI_DEVICE_ID_4S,
91          .subvendor = 0x1397,
92          .subdevice = 0x08b4,
93          .driver_data =
94          (unsigned long) &((hfc4s8s_param) {CHIP_ID_4S, CLOCKMODE_0, 4,
95                                             "HFC-4S Evaluation Board"}),
96          },
97         {.vendor = PCI_VENDOR_ID_CCD,
98          .device = PCI_DEVICE_ID_8S,
99          .subvendor = 0x1397,
100          .subdevice = 0x16b8,
101          .driver_data =
102          (unsigned long) &((hfc4s8s_param) {CHIP_ID_8S, CLOCKMODE_0, 8,
103                                             "HFC-8S Evaluation Board"}),
104          },
105         {.vendor = PCI_VENDOR_ID_CCD,
106          .device = PCI_DEVICE_ID_4S,
107          .subvendor = 0x1397,
108          .subdevice = 0xb520,
109          .driver_data =
110          (unsigned long) &((hfc4s8s_param) {CHIP_ID_4S, CLOCKMODE_1, 4,
111                                             "IOB4ST"}),
112          },
113         {.vendor = PCI_VENDOR_ID_CCD,
114          .device = PCI_DEVICE_ID_8S,
115          .subvendor = 0x1397,
116          .subdevice = 0xb522,
117          .driver_data =
118          (unsigned long) &((hfc4s8s_param) {CHIP_ID_8S, CLOCKMODE_1, 8,
119                                             "IOB8ST"}),
120          },
121         {}
122 };
123
124 MODULE_DEVICE_TABLE(pci, hfc4s8s_ids);
125
126 MODULE_AUTHOR("Werner Cornelius, werner@cornelius-consult.de");
127 MODULE_DESCRIPTION("ISDN layer 1 for Cologne Chip HFC-4S/8S chips");
128 MODULE_LICENSE("GPL");
129
130 /***********/
131 /* layer 1 */
132 /***********/
133 struct hfc4s8s_btype {
134         spinlock_t lock;
135         struct hisax_b_if b_if;
136         struct hfc4s8s_l1 *l1p;
137         struct sk_buff_head tx_queue;
138         struct sk_buff *tx_skb;
139         struct sk_buff *rx_skb;
140         __u8 *rx_ptr;
141         int tx_cnt;
142         int bchan;
143         int mode;
144 };
145
146 struct _hfc4s8s_hw;
147
148 struct hfc4s8s_l1 {
149         spinlock_t lock;
150         struct _hfc4s8s_hw *hw; /* pointer to hardware area */
151         int l1_state;           /* actual l1 state */
152         struct timer_list l1_timer;     /* layer 1 timer structure */
153         int nt_mode;            /* set to nt mode */
154         int st_num;             /* own index */
155         int enabled;            /* interface is enabled */
156         struct sk_buff_head d_tx_queue; /* send queue */
157         int tx_cnt;             /* bytes to send */
158         struct hisax_d_if d_if; /* D-channel interface */
159         struct hfc4s8s_btype b_ch[2];   /* B-channel data */
160         struct hisax_b_if *b_table[2];
161 };
162
163 /**********************/
164 /* hardware structure */
165 /**********************/
166 typedef struct _hfc4s8s_hw {
167         spinlock_t lock;
168
169         int cardnum;
170         int ifnum;
171         int iobase;
172         int nt_mode;
173         u_char *membase;
174         u_char *hw_membase;
175         void *pdev;
176         int max_fifo;
177         hfc4s8s_param driver_data;
178         int irq;
179         int fifo_sched_cnt;
180         struct work_struct tqueue;
181         struct hfc4s8s_l1 l1[HFC_MAX_ST];
182         char card_name[60];
183         struct {
184                 u_char r_irq_ctrl;
185                 u_char r_ctrl0;
186                 volatile u_char r_irq_statech;  /* active isdn l1 status */
187                 u_char r_irqmsk_statchg;        /* enabled isdn status ints */
188                 u_char r_irq_fifo_blx[8];       /* fifo status registers */
189                 u_char fifo_rx_trans_enables[8];        /* mask for enabled transparent rx fifos */
190                 u_char fifo_slow_timer_service[8];      /* mask for fifos needing slower timer service */
191                 volatile u_char r_irq_oview;    /* contents of overview register */
192                 volatile u_char timer_irq;
193                 int timer_usg_cnt;      /* number of channels using timer */
194         } mr;
195 } hfc4s8s_hw;
196
197
198
199 /***************************/
200 /* inline function defines */
201 /***************************/
202 #ifdef CONFIG_HISAX_HFC4S8S_PCIMEM      /* inline functions mempry mapped */
203
204 /* memory write and dummy IO read to avoid PCI byte merge problems */
205 #define Write_hfc8(a,b,c) {(*((volatile u_char *)(a->membase+b)) = c); inb(a->iobase+4);}
206 /* memory write without dummy IO access for fifo data access */
207 #define fWrite_hfc8(a,b,c) (*((volatile u_char *)(a->membase+b)) = c)
208 #define Read_hfc8(a,b) (*((volatile u_char *)(a->membase+b)))
209 #define Write_hfc16(a,b,c) (*((volatile unsigned short *)(a->membase+b)) = c)
210 #define Read_hfc16(a,b) (*((volatile unsigned short *)(a->membase+b)))
211 #define Write_hfc32(a,b,c) (*((volatile unsigned long *)(a->membase+b)) = c)
212 #define Read_hfc32(a,b) (*((volatile unsigned long *)(a->membase+b)))
213 #define wait_busy(a) {while ((Read_hfc8(a, R_STATUS) & M_BUSY));}
214 #define PCI_ENA_MEMIO   0x03
215
216 #else
217
218 /* inline functions io mapped */
219 static inline void
220 SetRegAddr(hfc4s8s_hw * a, u_char b)
221 {
222         outb(b, (a->iobase) + 4);
223 }
224
225 static inline u_char
226 GetRegAddr(hfc4s8s_hw * a)
227 {
228         return (inb((volatile u_int) (a->iobase + 4)));
229 }
230
231
232 static inline void
233 Write_hfc8(hfc4s8s_hw * a, u_char b, u_char c)
234 {
235         SetRegAddr(a, b);
236         outb(c, a->iobase);
237 }
238
239 static inline void
240 fWrite_hfc8(hfc4s8s_hw * a, u_char c)
241 {
242         outb(c, a->iobase);
243 }
244
245 static inline void
246 Write_hfc16(hfc4s8s_hw * a, u_char b, u_short c)
247 {
248         SetRegAddr(a, b);
249         outw(c, a->iobase);
250 }
251
252 static inline void
253 Write_hfc32(hfc4s8s_hw * a, u_char b, u_long c)
254 {
255         SetRegAddr(a, b);
256         outl(c, a->iobase);
257 }
258
259 static inline void
260 fWrite_hfc32(hfc4s8s_hw * a, u_long c)
261 {
262         outl(c, a->iobase);
263 }
264
265 static inline u_char
266 Read_hfc8(hfc4s8s_hw * a, u_char b)
267 {
268         SetRegAddr(a, b);
269         return (inb((volatile u_int) a->iobase));
270 }
271
272 static inline u_char
273 fRead_hfc8(hfc4s8s_hw * a)
274 {
275         return (inb((volatile u_int) a->iobase));
276 }
277
278
279 static inline u_short
280 Read_hfc16(hfc4s8s_hw * a, u_char b)
281 {
282         SetRegAddr(a, b);
283         return (inw((volatile u_int) a->iobase));
284 }
285
286 static inline u_long
287 Read_hfc32(hfc4s8s_hw * a, u_char b)
288 {
289         SetRegAddr(a, b);
290         return (inl((volatile u_int) a->iobase));
291 }
292
293 static inline u_long
294 fRead_hfc32(hfc4s8s_hw * a)
295 {
296         return (inl((volatile u_int) a->iobase));
297 }
298
299 static inline void
300 wait_busy(hfc4s8s_hw * a)
301 {
302         SetRegAddr(a, R_STATUS);
303         while (inb((volatile u_int) a->iobase) & M_BUSY);
304 }
305
306 #define PCI_ENA_REGIO   0x01
307
308 #endif                          /* CONFIG_HISAX_HFC4S8S_PCIMEM */
309
310 /******************************************************/
311 /* function to read critical counter registers that   */
312 /* may be udpated by the chip during read             */
313 /******************************************************/
314 static u_char
315 Read_hfc8_stable(hfc4s8s_hw * hw, int reg)
316 {
317         u_char ref8;
318         u_char in8;
319         ref8 = Read_hfc8(hw, reg);
320         while (((in8 = Read_hfc8(hw, reg)) != ref8)) {
321                 ref8 = in8;
322         }
323         return in8;
324 }
325
326 static int
327 Read_hfc16_stable(hfc4s8s_hw * hw, int reg)
328 {
329         int ref16;
330         int in16;
331
332         ref16 = Read_hfc16(hw, reg);
333         while (((in16 = Read_hfc16(hw, reg)) != ref16)) {
334                 ref16 = in16;
335         }
336         return in16;
337 }
338
339 /*****************************/
340 /* D-channel call from HiSax */
341 /*****************************/
342 static void
343 dch_l2l1(struct hisax_d_if *iface, int pr, void *arg)
344 {
345         struct hfc4s8s_l1 *l1 = iface->ifc.priv;
346         struct sk_buff *skb = (struct sk_buff *) arg;
347         u_long flags;
348
349         switch (pr) {
350
351                 case (PH_DATA | REQUEST):
352                         if (!l1->enabled) {
353                                 dev_kfree_skb(skb);
354                                 break;
355                         }
356                         spin_lock_irqsave(&l1->lock, flags);
357                         skb_queue_tail(&l1->d_tx_queue, skb);
358                         if ((skb_queue_len(&l1->d_tx_queue) == 1) &&
359                             (l1->tx_cnt <= 0)) {
360                                 l1->hw->mr.r_irq_fifo_blx[l1->st_num] |=
361                                     0x10;
362                                 spin_unlock_irqrestore(&l1->lock, flags);
363                                 schedule_work(&l1->hw->tqueue);
364                         } else
365                                 spin_unlock_irqrestore(&l1->lock, flags);
366                         break;
367
368                 case (PH_ACTIVATE | REQUEST):
369                         if (!l1->enabled)
370                                 break;
371                         if (!l1->nt_mode) {
372                                 if (l1->l1_state < 6) {
373                                         spin_lock_irqsave(&l1->lock,
374                                                           flags);
375
376                                         Write_hfc8(l1->hw, R_ST_SEL,
377                                                    l1->st_num);
378                                         Write_hfc8(l1->hw, A_ST_WR_STA,
379                                                    0x60);
380                                         mod_timer(&l1->l1_timer,
381                                                   jiffies + L1_TIMER_T3);
382                                         spin_unlock_irqrestore(&l1->lock,
383                                                                flags);
384                                 } else if (l1->l1_state == 7)
385                                         l1->d_if.ifc.l1l2(&l1->d_if.ifc,
386                                                           PH_ACTIVATE |
387                                                           INDICATION,
388                                                           NULL);
389                         } else {
390                                 if (l1->l1_state != 3) {
391                                         spin_lock_irqsave(&l1->lock,
392                                                           flags);
393                                         Write_hfc8(l1->hw, R_ST_SEL,
394                                                    l1->st_num);
395                                         Write_hfc8(l1->hw, A_ST_WR_STA,
396                                                    0x60);
397                                         spin_unlock_irqrestore(&l1->lock,
398                                                                flags);
399                                 } else if (l1->l1_state == 3)
400                                         l1->d_if.ifc.l1l2(&l1->d_if.ifc,
401                                                           PH_ACTIVATE |
402                                                           INDICATION,
403                                                           NULL);
404                         }
405                         break;
406
407                 default:
408                         printk(KERN_INFO
409                                "HFC-4S/8S: Unknown D-chan cmd 0x%x received, ignored\n",
410                                pr);
411                         break;
412         }
413         if (!l1->enabled)
414                 l1->d_if.ifc.l1l2(&l1->d_if.ifc,
415                                   PH_DEACTIVATE | INDICATION, NULL);
416 }                               /* dch_l2l1 */
417
418 /*****************************/
419 /* B-channel call from HiSax */
420 /*****************************/
421 static void
422 bch_l2l1(struct hisax_if *ifc, int pr, void *arg)
423 {
424         struct hfc4s8s_btype *bch = ifc->priv;
425         struct hfc4s8s_l1 *l1 = bch->l1p;
426         struct sk_buff *skb = (struct sk_buff *) arg;
427         long mode = (long) arg;
428         u_long flags;
429
430         switch (pr) {
431
432                 case (PH_DATA | REQUEST):
433                         if (!l1->enabled || (bch->mode == L1_MODE_NULL)) {
434                                 dev_kfree_skb(skb);
435                                 break;
436                         }
437                         spin_lock_irqsave(&l1->lock, flags);
438                         skb_queue_tail(&bch->tx_queue, skb);
439                         if (!bch->tx_skb && (bch->tx_cnt <= 0)) {
440                                 l1->hw->mr.r_irq_fifo_blx[l1->st_num] |=
441                                     ((bch->bchan == 1) ? 1 : 4);
442                                 spin_unlock_irqrestore(&l1->lock, flags);
443                                 schedule_work(&l1->hw->tqueue);
444                         } else
445                                 spin_unlock_irqrestore(&l1->lock, flags);
446                         break;
447
448                 case (PH_ACTIVATE | REQUEST):
449                 case (PH_DEACTIVATE | REQUEST):
450                         if (!l1->enabled)
451                                 break;
452                         if (pr == (PH_DEACTIVATE | REQUEST))
453                                 mode = L1_MODE_NULL;
454
455                         switch (mode) {
456                                 case L1_MODE_HDLC:
457                                         spin_lock_irqsave(&l1->lock,
458                                                           flags);
459                                         l1->hw->mr.timer_usg_cnt++;
460                                         l1->hw->mr.
461                                             fifo_slow_timer_service[l1->
462                                                                     st_num]
463                                             |=
464                                             ((bch->bchan ==
465                                               1) ? 0x2 : 0x8);
466                                         Write_hfc8(l1->hw, R_FIFO,
467                                                    (l1->st_num * 8 +
468                                                     ((bch->bchan ==
469                                                       1) ? 0 : 2)));
470                                         wait_busy(l1->hw);
471                                         Write_hfc8(l1->hw, A_CON_HDLC, 0xc);    /* HDLC mode, flag fill, connect ST */
472                                         Write_hfc8(l1->hw, A_SUBCH_CFG, 0);     /* 8 bits */
473                                         Write_hfc8(l1->hw, A_IRQ_MSK, 1);       /* enable TX interrupts for hdlc */
474                                         Write_hfc8(l1->hw, A_INC_RES_FIFO, 2);  /* reset fifo */
475                                         wait_busy(l1->hw);
476
477                                         Write_hfc8(l1->hw, R_FIFO,
478                                                    (l1->st_num * 8 +
479                                                     ((bch->bchan ==
480                                                       1) ? 1 : 3)));
481                                         wait_busy(l1->hw);
482                                         Write_hfc8(l1->hw, A_CON_HDLC, 0xc);    /* HDLC mode, flag fill, connect ST */
483                                         Write_hfc8(l1->hw, A_SUBCH_CFG, 0);     /* 8 bits */
484                                         Write_hfc8(l1->hw, A_IRQ_MSK, 1);       /* enable RX interrupts for hdlc */
485                                         Write_hfc8(l1->hw, A_INC_RES_FIFO, 2);  /* reset fifo */
486
487                                         Write_hfc8(l1->hw, R_ST_SEL,
488                                                    l1->st_num);
489                                         l1->hw->mr.r_ctrl0 |=
490                                             (bch->bchan & 3);
491                                         Write_hfc8(l1->hw, A_ST_CTRL0,
492                                                    l1->hw->mr.r_ctrl0);
493                                         bch->mode = L1_MODE_HDLC;
494                                         spin_unlock_irqrestore(&l1->lock,
495                                                                flags);
496
497                                         bch->b_if.ifc.l1l2(&bch->b_if.ifc,
498                                                            PH_ACTIVATE |
499                                                            INDICATION,
500                                                            NULL);
501                                         break;
502
503                                 case L1_MODE_TRANS:
504                                         spin_lock_irqsave(&l1->lock,
505                                                           flags);
506                                         l1->hw->mr.
507                                             fifo_rx_trans_enables[l1->
508                                                                   st_num]
509                                             |=
510                                             ((bch->bchan ==
511                                               1) ? 0x2 : 0x8);
512                                         l1->hw->mr.timer_usg_cnt++;
513                                         Write_hfc8(l1->hw, R_FIFO,
514                                                    (l1->st_num * 8 +
515                                                     ((bch->bchan ==
516                                                       1) ? 0 : 2)));
517                                         wait_busy(l1->hw);
518                                         Write_hfc8(l1->hw, A_CON_HDLC, 0xf);    /* Transparent mode, 1 fill, connect ST */
519                                         Write_hfc8(l1->hw, A_SUBCH_CFG, 0);     /* 8 bits */
520                                         Write_hfc8(l1->hw, A_IRQ_MSK, 0);       /* disable TX interrupts */
521                                         Write_hfc8(l1->hw, A_INC_RES_FIFO, 2);  /* reset fifo */
522                                         wait_busy(l1->hw);
523
524                                         Write_hfc8(l1->hw, R_FIFO,
525                                                    (l1->st_num * 8 +
526                                                     ((bch->bchan ==
527                                                       1) ? 1 : 3)));
528                                         wait_busy(l1->hw);
529                                         Write_hfc8(l1->hw, A_CON_HDLC, 0xf);    /* Transparent mode, 1 fill, connect ST */
530                                         Write_hfc8(l1->hw, A_SUBCH_CFG, 0);     /* 8 bits */
531                                         Write_hfc8(l1->hw, A_IRQ_MSK, 0);       /* disable RX interrupts */
532                                         Write_hfc8(l1->hw, A_INC_RES_FIFO, 2);  /* reset fifo */
533
534                                         Write_hfc8(l1->hw, R_ST_SEL,
535                                                    l1->st_num);
536                                         l1->hw->mr.r_ctrl0 |=
537                                             (bch->bchan & 3);
538                                         Write_hfc8(l1->hw, A_ST_CTRL0,
539                                                    l1->hw->mr.r_ctrl0);
540                                         bch->mode = L1_MODE_TRANS;
541                                         spin_unlock_irqrestore(&l1->lock,
542                                                                flags);
543
544                                         bch->b_if.ifc.l1l2(&bch->b_if.ifc,
545                                                            PH_ACTIVATE |
546                                                            INDICATION,
547                                                            NULL);
548                                         break;
549
550                                 default:
551                                         if (bch->mode == L1_MODE_NULL)
552                                                 break;
553                                         spin_lock_irqsave(&l1->lock,
554                                                           flags);
555                                         l1->hw->mr.
556                                             fifo_slow_timer_service[l1->
557                                                                     st_num]
558                                             &=
559                                             ~((bch->bchan ==
560                                                1) ? 0x3 : 0xc);
561                                         l1->hw->mr.
562                                             fifo_rx_trans_enables[l1->
563                                                                   st_num]
564                                             &=
565                                             ~((bch->bchan ==
566                                                1) ? 0x3 : 0xc);
567                                         l1->hw->mr.timer_usg_cnt--;
568                                         Write_hfc8(l1->hw, R_FIFO,
569                                                    (l1->st_num * 8 +
570                                                     ((bch->bchan ==
571                                                       1) ? 0 : 2)));
572                                         wait_busy(l1->hw);
573                                         Write_hfc8(l1->hw, A_IRQ_MSK, 0);       /* disable TX interrupts */
574                                         wait_busy(l1->hw);
575                                         Write_hfc8(l1->hw, R_FIFO,
576                                                    (l1->st_num * 8 +
577                                                     ((bch->bchan ==
578                                                       1) ? 1 : 3)));
579                                         wait_busy(l1->hw);
580                                         Write_hfc8(l1->hw, A_IRQ_MSK, 0);       /* disable RX interrupts */
581                                         Write_hfc8(l1->hw, R_ST_SEL,
582                                                    l1->st_num);
583                                         l1->hw->mr.r_ctrl0 &=
584                                             ~(bch->bchan & 3);
585                                         Write_hfc8(l1->hw, A_ST_CTRL0,
586                                                    l1->hw->mr.r_ctrl0);
587                                         spin_unlock_irqrestore(&l1->lock,
588                                                                flags);
589
590                                         bch->mode = L1_MODE_NULL;
591                                         bch->b_if.ifc.l1l2(&bch->b_if.ifc,
592                                                            PH_DEACTIVATE |
593                                                            INDICATION,
594                                                            NULL);
595                                         if (bch->tx_skb) {
596                                                 dev_kfree_skb(bch->tx_skb);
597                                                 bch->tx_skb = NULL;
598                                         }
599                                         if (bch->rx_skb) {
600                                                 dev_kfree_skb(bch->rx_skb);
601                                                 bch->rx_skb = NULL;
602                                         }
603                                         skb_queue_purge(&bch->tx_queue);
604                                         bch->tx_cnt = 0;
605                                         bch->rx_ptr = NULL;
606                                         break;
607                         }
608
609                         /* timer is only used when at least one b channel */
610                         /* is set up to transparent mode */
611                         if (l1->hw->mr.timer_usg_cnt) {
612                                 Write_hfc8(l1->hw, R_IRQMSK_MISC,
613                                            M_TI_IRQMSK);
614                         } else {
615                                 Write_hfc8(l1->hw, R_IRQMSK_MISC, 0);
616                         }
617
618                         break;
619
620                 default:
621                         printk(KERN_INFO
622                                "HFC-4S/8S: Unknown B-chan cmd 0x%x received, ignored\n",
623                                pr);
624                         break;
625         }
626         if (!l1->enabled)
627                 bch->b_if.ifc.l1l2(&bch->b_if.ifc,
628                                    PH_DEACTIVATE | INDICATION, NULL);
629 }                               /* bch_l2l1 */
630
631 /**************************/
632 /* layer 1 timer function */
633 /**************************/
634 static void
635 hfc_l1_timer(struct hfc4s8s_l1 *l1)
636 {
637         u_long flags;
638
639         if (!l1->enabled)
640                 return;
641
642         spin_lock_irqsave(&l1->lock, flags);
643         if (l1->nt_mode) {
644                 l1->l1_state = 1;
645                 Write_hfc8(l1->hw, R_ST_SEL, l1->st_num);
646                 Write_hfc8(l1->hw, A_ST_WR_STA, 0x11);
647                 spin_unlock_irqrestore(&l1->lock, flags);
648                 l1->d_if.ifc.l1l2(&l1->d_if.ifc,
649                                   PH_DEACTIVATE | INDICATION, NULL);
650                 spin_lock_irqsave(&l1->lock, flags);
651                 l1->l1_state = 1;
652                 Write_hfc8(l1->hw, A_ST_WR_STA, 0x1);
653                 spin_unlock_irqrestore(&l1->lock, flags);
654         } else {
655                 /* activation timed out */
656                 Write_hfc8(l1->hw, R_ST_SEL, l1->st_num);
657                 Write_hfc8(l1->hw, A_ST_WR_STA, 0x13);
658                 spin_unlock_irqrestore(&l1->lock, flags);
659                 l1->d_if.ifc.l1l2(&l1->d_if.ifc,
660                                   PH_DEACTIVATE | INDICATION, NULL);
661                 spin_lock_irqsave(&l1->lock, flags);
662                 Write_hfc8(l1->hw, R_ST_SEL, l1->st_num);
663                 Write_hfc8(l1->hw, A_ST_WR_STA, 0x3);
664                 spin_unlock_irqrestore(&l1->lock, flags);
665         }
666 }                               /* hfc_l1_timer */
667
668 /****************************************/
669 /* a complete D-frame has been received */
670 /****************************************/
671 static void
672 rx_d_frame(struct hfc4s8s_l1 *l1p, int ech)
673 {
674         int z1, z2;
675         u_char f1, f2, df;
676         struct sk_buff *skb;
677         u_char *cp;
678
679
680         if (!l1p->enabled)
681                 return;
682         do {
683                 /* E/D RX fifo */
684                 Write_hfc8(l1p->hw, R_FIFO,
685                            (l1p->st_num * 8 + ((ech) ? 7 : 5)));
686                 wait_busy(l1p->hw);
687
688                 f1 = Read_hfc8_stable(l1p->hw, A_F1);
689                 f2 = Read_hfc8(l1p->hw, A_F2);
690                 df = f1 - f2;
691                 if ((f1 - f2) < 0)
692                         df = f1 - f2 + MAX_F_CNT + 1;
693
694
695                 if (!df) {
696                         return; /* no complete frame in fifo */
697                 }
698
699                 z1 = Read_hfc16_stable(l1p->hw, A_Z1);
700                 z2 = Read_hfc16(l1p->hw, A_Z2);
701
702                 z1 = z1 - z2 + 1;
703                 if (z1 < 0)
704                         z1 += 384;
705
706                 if (!(skb = dev_alloc_skb(MAX_D_FRAME_SIZE))) {
707                         printk(KERN_INFO
708                                "HFC-4S/8S: Could not allocate D/E "
709                                "channel receive buffer");
710                         Write_hfc8(l1p->hw, A_INC_RES_FIFO, 2);
711                         wait_busy(l1p->hw);
712                         return;
713                 }
714
715                 if (((z1 < 4) || (z1 > MAX_D_FRAME_SIZE))) {
716                         if (skb)
717                                 dev_kfree_skb(skb);
718                         /* remove errornous D frame */
719                         if (df == 1) {
720                                 /* reset fifo */
721                                 Write_hfc8(l1p->hw, A_INC_RES_FIFO, 2);
722                                 wait_busy(l1p->hw);
723                                 return;
724                         } else {
725                                 /* read errornous D frame */
726
727 #ifndef CONFIG_HISAX_HFC4S8S_PCIMEM
728                                 SetRegAddr(l1p->hw, A_FIFO_DATA0);
729 #endif
730
731                                 while (z1 >= 4) {
732 #ifdef CONFIG_HISAX_HFC4S8S_PCIMEM
733                                         Read_hfc32(l1p->hw, A_FIFO_DATA0);
734 #else
735                                         fRead_hfc32(l1p->hw);
736 #endif
737                                         z1 -= 4;
738                                 }
739
740                                 while (z1--)
741 #ifdef CONFIG_HISAX_HFC4S8S_PCIMEM
742                                         Read_hfc8(l1p->hw, A_FIFO_DATA0);
743 #else
744                                         fRead_hfc8(l1p->hw);
745 #endif
746
747                                 Write_hfc8(l1p->hw, A_INC_RES_FIFO, 1);
748                                 wait_busy(l1p->hw);
749                                 return;
750                         }
751                 }
752
753                 cp = skb->data;
754
755 #ifndef CONFIG_HISAX_HFC4S8S_PCIMEM
756                 SetRegAddr(l1p->hw, A_FIFO_DATA0);
757 #endif
758
759                 while (z1 >= 4) {
760 #ifdef CONFIG_HISAX_HFC4S8S_PCIMEM
761                         *((unsigned long *) cp) =
762                             Read_hfc32(l1p->hw, A_FIFO_DATA0);
763 #else
764                         *((unsigned long *) cp) = fRead_hfc32(l1p->hw);
765 #endif
766                         cp += 4;
767                         z1 -= 4;
768                 }
769
770                 while (z1--)
771 #ifdef CONFIG_HISAX_HFC4S8S_PCIMEM
772                         *cp++ = Read_hfc8(l1p->hw, A_FIFO_DATA0);
773 #else
774                         *cp++ = fRead_hfc8(l1p->hw);
775 #endif
776
777                 Write_hfc8(l1p->hw, A_INC_RES_FIFO, 1); /* increment f counter */
778                 wait_busy(l1p->hw);
779
780                 if (*(--cp)) {
781                         dev_kfree_skb(skb);
782                 } else {
783                         skb->len = (cp - skb->data) - 2;
784                         if (ech)
785                                 l1p->d_if.ifc.l1l2(&l1p->d_if.ifc,
786                                                    PH_DATA_E | INDICATION,
787                                                    skb);
788                         else
789                                 l1p->d_if.ifc.l1l2(&l1p->d_if.ifc,
790                                                    PH_DATA | INDICATION,
791                                                    skb);
792                 }
793         } while (1);
794 }                               /* rx_d_frame */
795
796 /*************************************************************/
797 /* a B-frame has been received (perhaps not fully completed) */
798 /*************************************************************/
799 static void
800 rx_b_frame(struct hfc4s8s_btype *bch)
801 {
802         int z1, z2, hdlc_complete;
803         u_char f1, f2;
804         struct hfc4s8s_l1 *l1 = bch->l1p;
805         struct sk_buff *skb;
806
807         if (!l1->enabled || (bch->mode == L1_MODE_NULL))
808                 return;
809
810         do {
811                 /* RX Fifo */
812                 Write_hfc8(l1->hw, R_FIFO,
813                            (l1->st_num * 8 + ((bch->bchan == 1) ? 1 : 3)));
814                 wait_busy(l1->hw);
815
816                 if (bch->mode == L1_MODE_HDLC) {
817                         f1 = Read_hfc8_stable(l1->hw, A_F1);
818                         f2 = Read_hfc8(l1->hw, A_F2);
819                         hdlc_complete = ((f1 ^ f2) & MAX_F_CNT);
820                 } else
821                         hdlc_complete = 0;
822                 z1 = Read_hfc16_stable(l1->hw, A_Z1);
823                 z2 = Read_hfc16(l1->hw, A_Z2);
824                 z1 = (z1 - z2);
825                 if (hdlc_complete)
826                         z1++;
827                 if (z1 < 0)
828                         z1 += 384;
829
830                 if (!z1)
831                         break;
832
833                 if (!(skb = bch->rx_skb)) {
834                         if (!
835                             (skb =
836                              dev_alloc_skb((bch->mode ==
837                                             L1_MODE_TRANS) ? z1
838                                            : (MAX_B_FRAME_SIZE + 3)))) {
839                                 printk(KERN_ERR
840                                        "HFC-4S/8S: Could not allocate B "
841                                        "channel receive buffer");
842                                 return;
843                         }
844                         bch->rx_ptr = skb->data;
845                         bch->rx_skb = skb;
846                 }
847
848                 skb->len = (bch->rx_ptr - skb->data) + z1;
849
850                 /* HDLC length check */
851                 if ((bch->mode == L1_MODE_HDLC) &&
852                     ((hdlc_complete && (skb->len < 4)) ||
853                      (skb->len > (MAX_B_FRAME_SIZE + 3)))) {
854
855                         skb->len = 0;
856                         bch->rx_ptr = skb->data;
857                         Write_hfc8(l1->hw, A_INC_RES_FIFO, 2);  /* reset fifo */
858                         wait_busy(l1->hw);
859                         return;
860                 }
861 #ifndef CONFIG_HISAX_HFC4S8S_PCIMEM
862                 SetRegAddr(l1->hw, A_FIFO_DATA0);
863 #endif
864
865                 while (z1 >= 4) {
866 #ifdef CONFIG_HISAX_HFC4S8S_PCIMEM
867                         *((unsigned long *) bch->rx_ptr) =
868                             Read_hfc32(l1->hw, A_FIFO_DATA0);
869 #else
870                         *((unsigned long *) bch->rx_ptr) =
871                             fRead_hfc32(l1->hw);
872 #endif
873                         bch->rx_ptr += 4;
874                         z1 -= 4;
875                 }
876
877                 while (z1--)
878 #ifdef CONFIG_HISAX_HFC4S8S_PCIMEM
879                         *(bch->rx_ptr++) = Read_hfc8(l1->hw, A_FIFO_DATA0);
880 #else
881                         *(bch->rx_ptr++) = fRead_hfc8(l1->hw);
882 #endif
883
884                 if (hdlc_complete) {
885                         /* increment f counter */
886                         Write_hfc8(l1->hw, A_INC_RES_FIFO, 1);
887                         wait_busy(l1->hw);
888
889                         /* hdlc crc check */
890                         bch->rx_ptr--;
891                         if (*bch->rx_ptr) {
892                                 skb->len = 0;
893                                 bch->rx_ptr = skb->data;
894                                 continue;
895                         }
896                         skb->len -= 3;
897                 }
898                 if (hdlc_complete || (bch->mode == L1_MODE_TRANS)) {
899                         bch->rx_skb = NULL;
900                         bch->rx_ptr = NULL;
901                         bch->b_if.ifc.l1l2(&bch->b_if.ifc,
902                                            PH_DATA | INDICATION, skb);
903                 }
904
905         } while (1);
906 }                               /* rx_b_frame */
907
908 /********************************************/
909 /* a D-frame has been/should be transmitted */
910 /********************************************/
911 static void
912 tx_d_frame(struct hfc4s8s_l1 *l1p)
913 {
914         struct sk_buff *skb;
915         u_char f1, f2;
916         u_char *cp;
917         long cnt;
918
919         if (l1p->l1_state != 7)
920                 return;
921
922         /* TX fifo */
923         Write_hfc8(l1p->hw, R_FIFO, (l1p->st_num * 8 + 4));
924         wait_busy(l1p->hw);
925
926         f1 = Read_hfc8(l1p->hw, A_F1);
927         f2 = Read_hfc8_stable(l1p->hw, A_F2);
928
929         if ((f1 ^ f2) & MAX_F_CNT)
930                 return;         /* fifo is still filled */
931
932         if (l1p->tx_cnt > 0) {
933                 cnt = l1p->tx_cnt;
934                 l1p->tx_cnt = 0;
935                 l1p->d_if.ifc.l1l2(&l1p->d_if.ifc, PH_DATA | CONFIRM,
936                                    (void *) cnt);
937         }
938
939         if ((skb = skb_dequeue(&l1p->d_tx_queue))) {
940                 cp = skb->data;
941                 cnt = skb->len;
942 #ifndef CONFIG_HISAX_HFC4S8S_PCIMEM
943                 SetRegAddr(l1p->hw, A_FIFO_DATA0);
944 #endif
945
946                 while (cnt >= 4) {
947 #ifdef CONFIG_HISAX_HFC4S8S_PCIMEM
948                         fWrite_hfc32(l1p->hw, A_FIFO_DATA0,
949                                      *(unsigned long *) cp);
950 #else
951                         SetRegAddr(l1p->hw, A_FIFO_DATA0);
952                         fWrite_hfc32(l1p->hw, *(unsigned long *) cp);
953 #endif
954                         cp += 4;
955                         cnt -= 4;
956                 }
957
958 #ifdef CONFIG_HISAX_HFC4S8S_PCIMEM
959                 while (cnt--)
960                         fWrite_hfc8(l1p->hw, A_FIFO_DATA0, *cp++);
961 #else
962                 while (cnt--)
963                         fWrite_hfc8(l1p->hw, *cp++);
964 #endif
965
966                 l1p->tx_cnt = skb->truesize;
967                 Write_hfc8(l1p->hw, A_INC_RES_FIFO, 1); /* increment f counter */
968                 wait_busy(l1p->hw);
969
970                 dev_kfree_skb(skb);
971         }
972 }                               /* tx_d_frame */
973
974 /******************************************************/
975 /* a B-frame may be transmitted (or is not completed) */
976 /******************************************************/
977 static void
978 tx_b_frame(struct hfc4s8s_btype *bch)
979 {
980         struct sk_buff *skb;
981         struct hfc4s8s_l1 *l1 = bch->l1p;
982         u_char *cp;
983         int cnt, max, hdlc_num;
984         long ack_len = 0;
985
986         if (!l1->enabled || (bch->mode == L1_MODE_NULL))
987                 return;
988
989         /* TX fifo */
990         Write_hfc8(l1->hw, R_FIFO,
991                    (l1->st_num * 8 + ((bch->bchan == 1) ? 0 : 2)));
992         wait_busy(l1->hw);
993         do {
994
995                 if (bch->mode == L1_MODE_HDLC) {
996                         hdlc_num = Read_hfc8(l1->hw, A_F1) & MAX_F_CNT;
997                         hdlc_num -=
998                             (Read_hfc8_stable(l1->hw, A_F2) & MAX_F_CNT);
999                         if (hdlc_num < 0)
1000                                 hdlc_num += 16;
1001                         if (hdlc_num >= 15)
1002                                 break;  /* fifo still filled up with hdlc frames */
1003                 } else
1004                         hdlc_num = 0;
1005
1006                 if (!(skb = bch->tx_skb)) {
1007                         if (!(skb = skb_dequeue(&bch->tx_queue))) {
1008                                 l1->hw->mr.fifo_slow_timer_service[l1->
1009                                                                    st_num]
1010                                     &= ~((bch->bchan == 1) ? 1 : 4);
1011                                 break;  /* list empty */
1012                         }
1013                         bch->tx_skb = skb;
1014                         bch->tx_cnt = 0;
1015                 }
1016
1017                 if (!hdlc_num)
1018                         l1->hw->mr.fifo_slow_timer_service[l1->st_num] |=
1019                             ((bch->bchan == 1) ? 1 : 4);
1020                 else
1021                         l1->hw->mr.fifo_slow_timer_service[l1->st_num] &=
1022                             ~((bch->bchan == 1) ? 1 : 4);
1023
1024                 max = Read_hfc16_stable(l1->hw, A_Z2);
1025                 max -= Read_hfc16(l1->hw, A_Z1);
1026                 if (max <= 0)
1027                         max += 384;
1028                 max--;
1029
1030                 if (max < 16)
1031                         break;  /* don't write to small amounts of bytes */
1032
1033                 cnt = skb->len - bch->tx_cnt;
1034                 if (cnt > max)
1035                         cnt = max;
1036                 cp = skb->data + bch->tx_cnt;
1037                 bch->tx_cnt += cnt;
1038
1039 #ifndef CONFIG_HISAX_HFC4S8S_PCIMEM
1040                 SetRegAddr(l1->hw, A_FIFO_DATA0);
1041 #endif
1042                 while (cnt >= 4) {
1043 #ifdef CONFIG_HISAX_HFC4S8S_PCIMEM
1044                         fWrite_hfc32(l1->hw, A_FIFO_DATA0,
1045                                      *(unsigned long *) cp);
1046 #else
1047                         fWrite_hfc32(l1->hw, *(unsigned long *) cp);
1048 #endif
1049                         cp += 4;
1050                         cnt -= 4;
1051                 }
1052
1053                 while (cnt--)
1054 #ifdef CONFIG_HISAX_HFC4S8S_PCIMEM
1055                         fWrite_hfc8(l1->hw, A_FIFO_DATA0, *cp++);
1056 #else
1057                         fWrite_hfc8(l1->hw, *cp++);
1058 #endif
1059
1060                 if (bch->tx_cnt >= skb->len) {
1061                         if (bch->mode == L1_MODE_HDLC) {
1062                                 /* increment f counter */
1063                                 Write_hfc8(l1->hw, A_INC_RES_FIFO, 1);
1064                         }
1065                         ack_len += skb->truesize;
1066                         bch->tx_skb = NULL;
1067                         bch->tx_cnt = 0;
1068                         dev_kfree_skb(skb);
1069                 } else
1070                         /* Re-Select */
1071                         Write_hfc8(l1->hw, R_FIFO,
1072                                    (l1->st_num * 8 +
1073                                     ((bch->bchan == 1) ? 0 : 2)));
1074                 wait_busy(l1->hw);
1075         } while (1);
1076
1077         if (ack_len)
1078                 bch->b_if.ifc.l1l2((struct hisax_if *) &bch->b_if,
1079                                    PH_DATA | CONFIRM, (void *) ack_len);
1080 }                               /* tx_b_frame */
1081
1082 /*************************************/
1083 /* bottom half handler for interrupt */
1084 /*************************************/
1085 static void
1086 hfc4s8s_bh(hfc4s8s_hw * hw)
1087 {
1088         u_char b;
1089         struct hfc4s8s_l1 *l1p;
1090         volatile u_char *fifo_stat;
1091         int idx;
1092
1093         /* handle layer 1 state changes */
1094         b = 1;
1095         l1p = hw->l1;
1096         while (b) {
1097                 if ((b & hw->mr.r_irq_statech)) {
1098                         /* reset l1 event */
1099                         hw->mr.r_irq_statech &= ~b;
1100                         if (l1p->enabled) {
1101                                 if (l1p->nt_mode) {
1102                                         u_char oldstate = l1p->l1_state;
1103
1104                                         Write_hfc8(l1p->hw, R_ST_SEL,
1105                                                    l1p->st_num);
1106                                         l1p->l1_state =
1107                                             Read_hfc8(l1p->hw,
1108                                                       A_ST_RD_STA) & 0xf;
1109
1110                                         if ((oldstate == 3)
1111                                             && (l1p->l1_state != 3))
1112                                                 l1p->d_if.ifc.l1l2(&l1p->
1113                                                                    d_if.
1114                                                                    ifc,
1115                                                                    PH_DEACTIVATE
1116                                                                    |
1117                                                                    INDICATION,
1118                                                                    NULL);
1119
1120                                         if (l1p->l1_state != 2) {
1121                                                 del_timer(&l1p->l1_timer);
1122                                                 if (l1p->l1_state == 3) {
1123                                                         l1p->d_if.ifc.
1124                                                             l1l2(&l1p->
1125                                                                  d_if.ifc,
1126                                                                  PH_ACTIVATE
1127                                                                  |
1128                                                                  INDICATION,
1129                                                                  NULL);
1130                                                 }
1131                                         } else {
1132                                                 /* allow transition */
1133                                                 Write_hfc8(hw, A_ST_WR_STA,
1134                                                            M_SET_G2_G3);
1135                                                 mod_timer(&l1p->l1_timer,
1136                                                           jiffies +
1137                                                           L1_TIMER_T1);
1138                                         }
1139                                         printk(KERN_INFO
1140                                                "HFC-4S/8S: NT ch %d l1 state %d -> %d\n",
1141                                                l1p->st_num, oldstate,
1142                                                l1p->l1_state);
1143                                 } else {
1144                                         u_char oldstate = l1p->l1_state;
1145
1146                                         Write_hfc8(l1p->hw, R_ST_SEL,
1147                                                    l1p->st_num);
1148                                         l1p->l1_state =
1149                                             Read_hfc8(l1p->hw,
1150                                                       A_ST_RD_STA) & 0xf;
1151
1152                                         if (((l1p->l1_state == 3) &&
1153                                              ((oldstate == 7) ||
1154                                               (oldstate == 8))) ||
1155                                             ((timer_pending
1156                                               (&l1p->l1_timer))
1157                                              && (l1p->l1_state == 8))) {
1158                                                 mod_timer(&l1p->l1_timer,
1159                                                           L1_TIMER_T4 +
1160                                                           jiffies);
1161                                         } else {
1162                                                 if (l1p->l1_state == 7) {
1163                                                         del_timer(&l1p->
1164                                                                   l1_timer);
1165                                                         l1p->d_if.ifc.
1166                                                             l1l2(&l1p->
1167                                                                  d_if.ifc,
1168                                                                  PH_ACTIVATE
1169                                                                  |
1170                                                                  INDICATION,
1171                                                                  NULL);
1172                                                         tx_d_frame(l1p);
1173                                                 }
1174                                                 if (l1p->l1_state == 3) {
1175                                                         if (oldstate != 3)
1176                                                                 l1p->d_if.
1177                                                                     ifc.
1178                                                                     l1l2
1179                                                                     (&l1p->
1180                                                                      d_if.
1181                                                                      ifc,
1182                                                                      PH_DEACTIVATE
1183                                                                      |
1184                                                                      INDICATION,
1185                                                                      NULL);
1186                                                 }
1187                                         }
1188                                         printk(KERN_INFO
1189                                                "HFC-4S/8S: TE %d ch %d l1 state %d -> %d\n",
1190                                                l1p->hw->cardnum,
1191                                                l1p->st_num, oldstate,
1192                                                l1p->l1_state);
1193                                 }
1194                         }
1195                 }
1196                 b <<= 1;
1197                 l1p++;
1198         }
1199
1200         /* now handle the fifos */
1201         idx = 0;
1202         fifo_stat = hw->mr.r_irq_fifo_blx;
1203         l1p = hw->l1;
1204         while (idx < hw->driver_data.max_st_ports) {
1205
1206                 if (hw->mr.timer_irq) {
1207                         *fifo_stat |= hw->mr.fifo_rx_trans_enables[idx];
1208                         if (hw->fifo_sched_cnt <= 0) {
1209                                 *fifo_stat |=
1210                                     hw->mr.fifo_slow_timer_service[l1p->
1211                                                                    st_num];
1212                         }
1213                 }
1214                 /* ignore fifo 6 (TX E fifo) */
1215                 *fifo_stat &= 0xff - 0x40;
1216
1217                 while (*fifo_stat) {
1218
1219                         if (!l1p->nt_mode) {
1220                                 /* RX Fifo has data to read */
1221                                 if ((*fifo_stat & 0x20)) {
1222                                         *fifo_stat &= ~0x20;
1223                                         rx_d_frame(l1p, 0);
1224                                 }
1225                                 /* E Fifo has data to read */
1226                                 if ((*fifo_stat & 0x80)) {
1227                                         *fifo_stat &= ~0x80;
1228                                         rx_d_frame(l1p, 1);
1229                                 }
1230                                 /* TX Fifo completed send */
1231                                 if ((*fifo_stat & 0x10)) {
1232                                         *fifo_stat &= ~0x10;
1233                                         tx_d_frame(l1p);
1234                                 }
1235                         }
1236                         /* B1 RX Fifo has data to read */
1237                         if ((*fifo_stat & 0x2)) {
1238                                 *fifo_stat &= ~0x2;
1239                                 rx_b_frame(l1p->b_ch);
1240                         }
1241                         /* B1 TX Fifo has send completed */
1242                         if ((*fifo_stat & 0x1)) {
1243                                 *fifo_stat &= ~0x1;
1244                                 tx_b_frame(l1p->b_ch);
1245                         }
1246                         /* B2 RX Fifo has data to read */
1247                         if ((*fifo_stat & 0x8)) {
1248                                 *fifo_stat &= ~0x8;
1249                                 rx_b_frame(l1p->b_ch + 1);
1250                         }
1251                         /* B2 TX Fifo has send completed */
1252                         if ((*fifo_stat & 0x4)) {
1253                                 *fifo_stat &= ~0x4;
1254                                 tx_b_frame(l1p->b_ch + 1);
1255                         }
1256                 }
1257                 fifo_stat++;
1258                 l1p++;
1259                 idx++;
1260         }
1261
1262         if (hw->fifo_sched_cnt <= 0)
1263                 hw->fifo_sched_cnt += (1 << (7 - TRANS_TIMER_MODE));
1264         hw->mr.timer_irq = 0;   /* clear requested timer irq */
1265 }                               /* hfc4s8s_bh */
1266
1267 /*********************/
1268 /* interrupt handler */
1269 /*********************/
1270 static irqreturn_t
1271 hfc4s8s_interrupt(int intno, void *dev_id)
1272 {
1273         hfc4s8s_hw *hw = dev_id;
1274         u_char b, ovr;
1275         volatile u_char *ovp;
1276         int idx;
1277         u_char old_ioreg;
1278
1279         if (!hw || !(hw->mr.r_irq_ctrl & M_GLOB_IRQ_EN))
1280                 return IRQ_NONE;
1281
1282 #ifndef CONFIG_HISAX_HFC4S8S_PCIMEM
1283         /* read current selected regsister */
1284         old_ioreg = GetRegAddr(hw);
1285 #endif
1286
1287         /* Layer 1 State change */
1288         hw->mr.r_irq_statech |=
1289             (Read_hfc8(hw, R_SCI) & hw->mr.r_irqmsk_statchg);
1290         if (!
1291             (b = (Read_hfc8(hw, R_STATUS) & (M_MISC_IRQSTA | M_FR_IRQSTA)))
1292 && !hw->mr.r_irq_statech) {
1293 #ifndef CONFIG_HISAX_HFC4S8S_PCIMEM
1294                 SetRegAddr(hw, old_ioreg);
1295 #endif
1296                 return IRQ_NONE;
1297         }
1298
1299         /* timer event */
1300         if (Read_hfc8(hw, R_IRQ_MISC) & M_TI_IRQ) {
1301                 hw->mr.timer_irq = 1;
1302                 hw->fifo_sched_cnt--;
1303         }
1304
1305         /* FIFO event */
1306         if ((ovr = Read_hfc8(hw, R_IRQ_OVIEW))) {
1307                 hw->mr.r_irq_oview |= ovr;
1308                 idx = R_IRQ_FIFO_BL0;
1309                 ovp = hw->mr.r_irq_fifo_blx;
1310                 while (ovr) {
1311                         if ((ovr & 1)) {
1312                                 *ovp |= Read_hfc8(hw, idx);
1313                         }
1314                         ovp++;
1315                         idx++;
1316                         ovr >>= 1;
1317                 }
1318         }
1319
1320         /* queue the request to allow other cards to interrupt */
1321         schedule_work(&hw->tqueue);
1322
1323 #ifndef CONFIG_HISAX_HFC4S8S_PCIMEM
1324         SetRegAddr(hw, old_ioreg);
1325 #endif
1326         return IRQ_HANDLED;
1327 }                               /* hfc4s8s_interrupt */
1328
1329 /***********************************************************************/
1330 /* reset the complete chip, don't release the chips irq but disable it */
1331 /***********************************************************************/
1332 static void
1333 chipreset(hfc4s8s_hw * hw)
1334 {
1335         u_long flags;
1336
1337         spin_lock_irqsave(&hw->lock, flags);
1338         Write_hfc8(hw, R_CTRL, 0);      /* use internal RAM */
1339         Write_hfc8(hw, R_RAM_MISC, 0);  /* 32k*8 RAM */
1340         Write_hfc8(hw, R_FIFO_MD, 0);   /* fifo mode 386 byte/fifo simple mode */
1341         Write_hfc8(hw, R_CIRM, M_SRES); /* reset chip */
1342         hw->mr.r_irq_ctrl = 0;  /* interrupt is inactive */
1343         spin_unlock_irqrestore(&hw->lock, flags);
1344
1345         udelay(3);
1346         Write_hfc8(hw, R_CIRM, 0);      /* disable reset */
1347         wait_busy(hw);
1348
1349         Write_hfc8(hw, R_PCM_MD0, M_PCM_MD);    /* master mode */
1350         Write_hfc8(hw, R_RAM_MISC, M_FZ_MD);    /* transmit fifo option */
1351         if (hw->driver_data.clock_mode == 1)
1352                 Write_hfc8(hw, R_BRG_PCM_CFG, M_PCM_CLK);       /* PCM clk / 2 */
1353         Write_hfc8(hw, R_TI_WD, TRANS_TIMER_MODE);      /* timer interval */
1354
1355         memset(&hw->mr, 0, sizeof(hw->mr));
1356 }                               /* chipreset */
1357
1358 /********************************************/
1359 /* disable/enable hardware in nt or te mode */
1360 /********************************************/
1361 static void
1362 hfc_hardware_enable(hfc4s8s_hw * hw, int enable, int nt_mode)
1363 {
1364         u_long flags;
1365         char if_name[40];
1366         int i;
1367
1368         if (enable) {
1369                 /* save system vars */
1370                 hw->nt_mode = nt_mode;
1371
1372                 /* enable fifo and state irqs, but not global irq enable */
1373                 hw->mr.r_irq_ctrl = M_FIFO_IRQ;
1374                 Write_hfc8(hw, R_IRQ_CTRL, hw->mr.r_irq_ctrl);
1375                 hw->mr.r_irqmsk_statchg = 0;
1376                 Write_hfc8(hw, R_SCI_MSK, hw->mr.r_irqmsk_statchg);
1377                 Write_hfc8(hw, R_PWM_MD, 0x80);
1378                 Write_hfc8(hw, R_PWM1, 26);
1379                 if (!nt_mode)
1380                         Write_hfc8(hw, R_ST_SYNC, M_AUTO_SYNC);
1381
1382                 /* enable the line interfaces and fifos */
1383                 for (i = 0; i < hw->driver_data.max_st_ports; i++) {
1384                         hw->mr.r_irqmsk_statchg |= (1 << i);
1385                         Write_hfc8(hw, R_SCI_MSK, hw->mr.r_irqmsk_statchg);
1386                         Write_hfc8(hw, R_ST_SEL, i);
1387                         Write_hfc8(hw, A_ST_CLK_DLY,
1388                                    ((nt_mode) ? CLKDEL_NT : CLKDEL_TE));
1389                         hw->mr.r_ctrl0 = ((nt_mode) ? CTRL0_NT : CTRL0_TE);
1390                         Write_hfc8(hw, A_ST_CTRL0, hw->mr.r_ctrl0);
1391                         Write_hfc8(hw, A_ST_CTRL2, 3);
1392                         Write_hfc8(hw, A_ST_WR_STA, 0); /* enable state machine */
1393
1394                         hw->l1[i].enabled = 1;
1395                         hw->l1[i].nt_mode = nt_mode;
1396
1397                         if (!nt_mode) {
1398                                 /* setup E-fifo */
1399                                 Write_hfc8(hw, R_FIFO, i * 8 + 7);      /* E fifo */
1400                                 wait_busy(hw);
1401                                 Write_hfc8(hw, A_CON_HDLC, 0x11);       /* HDLC mode, 1 fill, connect ST */
1402                                 Write_hfc8(hw, A_SUBCH_CFG, 2); /* only 2 bits */
1403                                 Write_hfc8(hw, A_IRQ_MSK, 1);   /* enable interrupt */
1404                                 Write_hfc8(hw, A_INC_RES_FIFO, 2);      /* reset fifo */
1405                                 wait_busy(hw);
1406
1407                                 /* setup D RX-fifo */
1408                                 Write_hfc8(hw, R_FIFO, i * 8 + 5);      /* RX fifo */
1409                                 wait_busy(hw);
1410                                 Write_hfc8(hw, A_CON_HDLC, 0x11);       /* HDLC mode, 1 fill, connect ST */
1411                                 Write_hfc8(hw, A_SUBCH_CFG, 2); /* only 2 bits */
1412                                 Write_hfc8(hw, A_IRQ_MSK, 1);   /* enable interrupt */
1413                                 Write_hfc8(hw, A_INC_RES_FIFO, 2);      /* reset fifo */
1414                                 wait_busy(hw);
1415
1416                                 /* setup D TX-fifo */
1417                                 Write_hfc8(hw, R_FIFO, i * 8 + 4);      /* TX fifo */
1418                                 wait_busy(hw);
1419                                 Write_hfc8(hw, A_CON_HDLC, 0x11);       /* HDLC mode, 1 fill, connect ST */
1420                                 Write_hfc8(hw, A_SUBCH_CFG, 2); /* only 2 bits */
1421                                 Write_hfc8(hw, A_IRQ_MSK, 1);   /* enable interrupt */
1422                                 Write_hfc8(hw, A_INC_RES_FIFO, 2);      /* reset fifo */
1423                                 wait_busy(hw);
1424                         }
1425
1426                         sprintf(if_name, "hfc4s8s_%d%d_", hw->cardnum, i);
1427
1428                         if (hisax_register
1429                             (&hw->l1[i].d_if, hw->l1[i].b_table, if_name,
1430                              ((nt_mode) ? 3 : 2))) {
1431
1432                                 hw->l1[i].enabled = 0;
1433                                 hw->mr.r_irqmsk_statchg &= ~(1 << i);
1434                                 Write_hfc8(hw, R_SCI_MSK,
1435                                            hw->mr.r_irqmsk_statchg);
1436                                 printk(KERN_INFO
1437                                        "HFC-4S/8S: Unable to register S/T device %s, break\n",
1438                                        if_name);
1439                                 break;
1440                         }
1441                 }
1442                 spin_lock_irqsave(&hw->lock, flags);
1443                 hw->mr.r_irq_ctrl |= M_GLOB_IRQ_EN;
1444                 Write_hfc8(hw, R_IRQ_CTRL, hw->mr.r_irq_ctrl);
1445                 spin_unlock_irqrestore(&hw->lock, flags);
1446         } else {
1447                 /* disable hardware */
1448                 spin_lock_irqsave(&hw->lock, flags);
1449                 hw->mr.r_irq_ctrl &= ~M_GLOB_IRQ_EN;
1450                 Write_hfc8(hw, R_IRQ_CTRL, hw->mr.r_irq_ctrl);
1451                 spin_unlock_irqrestore(&hw->lock, flags);
1452
1453                 for (i = hw->driver_data.max_st_ports - 1; i >= 0; i--) {
1454                         hw->l1[i].enabled = 0;
1455                         hisax_unregister(&hw->l1[i].d_if);
1456                         del_timer(&hw->l1[i].l1_timer);
1457                         skb_queue_purge(&hw->l1[i].d_tx_queue);
1458                         skb_queue_purge(&hw->l1[i].b_ch[0].tx_queue);
1459                         skb_queue_purge(&hw->l1[i].b_ch[1].tx_queue);
1460                 }
1461                 chipreset(hw);
1462         }
1463 }                               /* hfc_hardware_enable */
1464
1465 /******************************************/
1466 /* disable memory mapped ports / io ports */
1467 /******************************************/
1468 static void
1469 release_pci_ports(hfc4s8s_hw * hw)
1470 {
1471         pci_write_config_word(hw->pdev, PCI_COMMAND, 0);
1472 #ifdef CONFIG_HISAX_HFC4S8S_PCIMEM
1473         if (hw->membase)
1474                 iounmap((void *) hw->membase);
1475 #else
1476         if (hw->iobase)
1477                 release_region(hw->iobase, 8);
1478 #endif
1479 }
1480
1481 /*****************************************/
1482 /* enable memory mapped ports / io ports */
1483 /*****************************************/
1484 static void
1485 enable_pci_ports(hfc4s8s_hw * hw)
1486 {
1487 #ifdef CONFIG_HISAX_HFC4S8S_PCIMEM
1488         pci_write_config_word(hw->pdev, PCI_COMMAND, PCI_ENA_MEMIO);
1489 #else
1490         pci_write_config_word(hw->pdev, PCI_COMMAND, PCI_ENA_REGIO);
1491 #endif
1492 }
1493
1494 /*************************************/
1495 /* initialise the HFC-4s/8s hardware */
1496 /* return 0 on success.              */
1497 /*************************************/
1498 static int __devinit
1499 setup_instance(hfc4s8s_hw * hw)
1500 {
1501         int err = -EIO;
1502         int i;
1503
1504         for (i = 0; i < HFC_MAX_ST; i++) {
1505                 struct hfc4s8s_l1 *l1p;
1506
1507                 l1p = hw->l1 + i;
1508                 spin_lock_init(&l1p->lock);
1509                 l1p->hw = hw;
1510                 l1p->l1_timer.function = (void *) hfc_l1_timer;
1511                 l1p->l1_timer.data = (long) (l1p);
1512                 init_timer(&l1p->l1_timer);
1513                 l1p->st_num = i;
1514                 skb_queue_head_init(&l1p->d_tx_queue);
1515                 l1p->d_if.ifc.priv = hw->l1 + i;
1516                 l1p->d_if.ifc.l2l1 = (void *) dch_l2l1;
1517
1518                 spin_lock_init(&l1p->b_ch[0].lock);
1519                 l1p->b_ch[0].b_if.ifc.l2l1 = (void *) bch_l2l1;
1520                 l1p->b_ch[0].b_if.ifc.priv = (void *) &l1p->b_ch[0];
1521                 l1p->b_ch[0].l1p = hw->l1 + i;
1522                 l1p->b_ch[0].bchan = 1;
1523                 l1p->b_table[0] = &l1p->b_ch[0].b_if;
1524                 skb_queue_head_init(&l1p->b_ch[0].tx_queue);
1525
1526                 spin_lock_init(&l1p->b_ch[1].lock);
1527                 l1p->b_ch[1].b_if.ifc.l2l1 = (void *) bch_l2l1;
1528                 l1p->b_ch[1].b_if.ifc.priv = (void *) &l1p->b_ch[1];
1529                 l1p->b_ch[1].l1p = hw->l1 + i;
1530                 l1p->b_ch[1].bchan = 2;
1531                 l1p->b_table[1] = &l1p->b_ch[1].b_if;
1532                 skb_queue_head_init(&l1p->b_ch[1].tx_queue);
1533         }
1534
1535         enable_pci_ports(hw);
1536         chipreset(hw);
1537
1538         i = Read_hfc8(hw, R_CHIP_ID) >> CHIP_ID_SHIFT;
1539         if (i != hw->driver_data.chip_id) {
1540                 printk(KERN_INFO
1541                        "HFC-4S/8S: invalid chip id 0x%x instead of 0x%x, card ignored\n",
1542                        i, hw->driver_data.chip_id);
1543                 goto out;
1544         }
1545
1546         i = Read_hfc8(hw, R_CHIP_RV) & 0xf;
1547         if (!i) {
1548                 printk(KERN_INFO
1549                        "HFC-4S/8S: chip revision 0 not supported, card ignored\n");
1550                 goto out;
1551         }
1552
1553         INIT_WORK(&hw->tqueue, (void *) (void *) hfc4s8s_bh, hw);
1554
1555         if (request_irq
1556             (hw->irq, hfc4s8s_interrupt, IRQF_SHARED, hw->card_name, hw)) {
1557                 printk(KERN_INFO
1558                        "HFC-4S/8S: unable to alloc irq %d, card ignored\n",
1559                        hw->irq);
1560                 goto out;
1561         }
1562 #ifdef CONFIG_HISAX_HFC4S8S_PCIMEM
1563         printk(KERN_INFO
1564                "HFC-4S/8S: found PCI card at membase 0x%p, irq %d\n",
1565                hw->hw_membase, hw->irq);
1566 #else
1567         printk(KERN_INFO
1568                "HFC-4S/8S: found PCI card at iobase 0x%x, irq %d\n",
1569                hw->iobase, hw->irq);
1570 #endif
1571
1572         hfc_hardware_enable(hw, 1, 0);
1573
1574         return (0);
1575
1576       out:
1577         hw->irq = 0;
1578         release_pci_ports(hw);
1579         kfree(hw);
1580         return (err);
1581 }
1582
1583 /*****************************************/
1584 /* PCI hotplug interface: probe new card */
1585 /*****************************************/
1586 static int __devinit
1587 hfc4s8s_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
1588 {
1589         int err = -ENOMEM;
1590         hfc4s8s_param *driver_data = (hfc4s8s_param *) ent->driver_data;
1591         hfc4s8s_hw *hw;
1592
1593         if (!(hw = kmalloc(sizeof(hfc4s8s_hw), GFP_ATOMIC))) {
1594                 printk(KERN_ERR "No kmem for HFC-4S/8S card\n");
1595                 return (err);
1596         }
1597         memset(hw, 0, sizeof(hfc4s8s_hw));
1598
1599         hw->pdev = pdev;
1600         err = pci_enable_device(pdev);
1601
1602         if (err)
1603                 goto out;
1604
1605         hw->cardnum = card_cnt;
1606         sprintf(hw->card_name, "hfc4s8s_%d", hw->cardnum);
1607         printk(KERN_INFO "HFC-4S/8S: found adapter %s (%s) at %s\n",
1608                driver_data->device_name, hw->card_name, pci_name(pdev));
1609
1610         spin_lock_init(&hw->lock);
1611
1612         hw->driver_data = *driver_data;
1613         hw->irq = pdev->irq;
1614         hw->iobase = pci_resource_start(pdev, 0);
1615
1616 #ifdef CONFIG_HISAX_HFC4S8S_PCIMEM
1617         hw->hw_membase = (u_char *) pci_resource_start(pdev, 1);
1618         hw->membase = ioremap((ulong) hw->hw_membase, 256);
1619 #else
1620         if (!request_region(hw->iobase, 8, hw->card_name)) {
1621                 printk(KERN_INFO
1622                        "HFC-4S/8S: failed to rquest address space at 0x%04x\n",
1623                        hw->iobase);
1624                 goto out;
1625         }
1626 #endif
1627
1628         pci_set_drvdata(pdev, hw);
1629         err = setup_instance(hw);
1630         if (!err)
1631                 card_cnt++;
1632         return (err);
1633
1634       out:
1635         kfree(hw);
1636         return (err);
1637 }
1638
1639 /**************************************/
1640 /* PCI hotplug interface: remove card */
1641 /**************************************/
1642 static void __devexit
1643 hfc4s8s_remove(struct pci_dev *pdev)
1644 {
1645         hfc4s8s_hw *hw = pci_get_drvdata(pdev);
1646
1647         printk(KERN_INFO "HFC-4S/8S: removing card %d\n", hw->cardnum);
1648         hfc_hardware_enable(hw, 0, 0);
1649
1650         if (hw->irq)
1651                 free_irq(hw->irq, hw);
1652         hw->irq = 0;
1653         release_pci_ports(hw);
1654
1655         card_cnt--;
1656         pci_disable_device(pdev);
1657         kfree(hw);
1658         return;
1659 }
1660
1661 static struct pci_driver hfc4s8s_driver = {
1662       .name     = "hfc4s8s_l1",
1663       .probe    = hfc4s8s_probe,
1664       .remove   = __devexit_p(hfc4s8s_remove),
1665       .id_table = hfc4s8s_ids,
1666 };
1667
1668 /**********************/
1669 /* driver Module init */
1670 /**********************/
1671 static int __init
1672 hfc4s8s_module_init(void)
1673 {
1674         int err;
1675
1676         printk(KERN_INFO
1677                "HFC-4S/8S: Layer 1 driver module for HFC-4S/8S isdn chips, %s\n",
1678                hfc4s8s_rev);
1679         printk(KERN_INFO
1680                "HFC-4S/8S: (C) 2003 Cornelius Consult, www.cornelius-consult.de\n");
1681
1682         card_cnt = 0;
1683
1684         err = pci_register_driver(&hfc4s8s_driver);
1685         if (err < 0) {
1686                 goto out;
1687         }
1688         printk(KERN_INFO "HFC-4S/8S: found %d cards\n", card_cnt);
1689
1690 #if !defined(CONFIG_HOTPLUG)
1691         if (err == 0) {
1692                 err = -ENODEV;
1693                 pci_unregister_driver(&hfc4s8s_driver);
1694                 goto out;
1695         }
1696 #endif
1697
1698         return 0;
1699       out:
1700         return (err);
1701 }                               /* hfc4s8s_init_hw */
1702
1703 /*************************************/
1704 /* driver module exit :              */
1705 /* release the HFC-4s/8s hardware    */
1706 /*************************************/
1707 static void __exit
1708 hfc4s8s_module_exit(void)
1709 {
1710         pci_unregister_driver(&hfc4s8s_driver);
1711         printk(KERN_INFO "HFC-4S/8S: module removed\n");
1712 }                               /* hfc4s8s_release_hw */
1713
1714 module_init(hfc4s8s_module_init);
1715 module_exit(hfc4s8s_module_exit);