switch (cq->op) {
        case MISDN_CTRL_GETOP:
-               cq->op = MISDN_CTRL_LOOP;
+               cq->op = MISDN_CTRL_LOOP | MISDN_CTRL_L1_TIMER3;
                break;
        case MISDN_CTRL_LOOP:
                /* cq->channel: 0 disable, 1 B1 loop 2 B2 loop, 3 both */
                }
                ret = fc->isac.ctrl(&fc->isac, HW_TESTLOOP, cq->channel);
                break;
+       case MISDN_CTRL_L1_TIMER3:
+               ret = fc->isac.ctrl(&fc->isac, HW_TIMER3_VALUE, cq->p1);
+               break;
        default:
                pr_info("%s: %s unknown Op %x\n", fc->name, __func__, cq->op);
                ret = -EINVAL;
 
 
        switch (cq->op) {
        case MISDN_CTRL_GETOP:
-               cq->op = MISDN_CTRL_HFC_OP;
+               cq->op = MISDN_CTRL_HFC_OP | MISDN_CTRL_L1_TIMER3;
                break;
        case MISDN_CTRL_HFC_WD_INIT: /* init the watchdog */
                wd_cnt = cq->p1 & 0xf;
                               __func__);
                HFC_outb(hc, R_BERT_WD_MD, hc->hw.r_bert_wd_md | V_WD_RES);
                break;
+       case MISDN_CTRL_L1_TIMER3:
+               ret = l1_event(dch->l1, HW_TIMER3_VALUE | (cq->p1 & 0xff));
+               break;
        default:
                printk(KERN_WARNING "%s: unknown Op %x\n",
                       __func__, cq->op);
 
        switch (cq->op) {
        case MISDN_CTRL_GETOP:
                cq->op = MISDN_CTRL_LOOP | MISDN_CTRL_CONNECT |
-                       MISDN_CTRL_DISCONNECT;
+                        MISDN_CTRL_DISCONNECT | MISDN_CTRL_L1_TIMER3;
                break;
        case MISDN_CTRL_LOOP:
                /* channel 0 disabled loop */
                Write_hfc(hc, HFCPCI_CONNECT, hc->hw.conn);
                hc->hw.trm &= 0x7f;     /* disable IOM-loop */
                break;
+       case MISDN_CTRL_L1_TIMER3:
+               ret = l1_event(hc->dch.l1, HW_TIMER3_VALUE | (cq->p1 & 0xff));
+               break;
        default:
                printk(KERN_WARNING "%s: unknown Op %x\n",
                       __func__, cq->op);
 
 }
 
 static int
-isac_ctrl(struct isac_hw *isac, u32 cmd, u_long para)
+isac_ctrl(struct isac_hw *isac, u32 cmd, unsigned long para)
 {
        u8 tl = 0;
-       u_long flags;
+       unsigned long flags;
+       int ret = 0;
 
        switch (cmd) {
        case HW_TESTLOOP:
                }
                spin_unlock_irqrestore(isac->hwlock, flags);
                break;
+       case HW_TIMER3_VALUE:
+               ret = l1_event(isac->dch.l1, HW_TIMER3_VALUE | (para & 0xff));
+               break;
        default:
                pr_debug("%s: %s unknown command %x %lx\n", isac->name,
                         __func__, cmd, para);
-               return -1;
+               ret = -1;
        }
-       return 0;
+       return ret;
 }
 
 static int
 
        switch (cq->op) {
        case MISDN_CTRL_GETOP:
-               cq->op = MISDN_CTRL_LOOP;
+               cq->op = MISDN_CTRL_LOOP | MISDN_CTRL_L1_TIMER3;
                break;
        case MISDN_CTRL_LOOP:
                /* cq->channel: 0 disable, 1 B1 loop 2 B2 loop, 3 both */
                }
                ret = ipac->ctrl(ipac, HW_TESTLOOP, cq->channel);
                break;
+       case MISDN_CTRL_L1_TIMER3:
+               ret = ipac->isac.ctrl(&ipac->isac, HW_TIMER3_VALUE, cq->p1);
+               break;
        default:
                pr_info("%s: unknown CTRL OP %x\n", ipac->name, cq->op);
                ret = -EINVAL;
 
 
        switch (cq->op) {
        case MISDN_CTRL_GETOP:
-               cq->op = MISDN_CTRL_LOOP;
+               cq->op = MISDN_CTRL_LOOP | MISDN_CTRL_L1_TIMER3;
                break;
        case MISDN_CTRL_LOOP:
                /* cq->channel: 0 disable, 1 B1 loop 2 B2 loop, 3 both */
                }
                ret = card->isac.ctrl(&card->isac, HW_TESTLOOP, cq->channel);
                break;
+       case MISDN_CTRL_L1_TIMER3:
+               ret = card->isac.ctrl(&card->isac, HW_TIMER3_VALUE, cq->p1);
+               break;
        default:
                pr_info("%s: %s unknown Op %x\n", card->name, __func__, cq->op);
                ret = -EINVAL;
 
 
        switch (cq->op) {
        case MISDN_CTRL_GETOP:
-               cq->op = MISDN_CTRL_LOOP;
+               cq->op = MISDN_CTRL_LOOP | MISDN_CTRL_L1_TIMER3;
                break;
        case MISDN_CTRL_LOOP:
                /* cq->channel: 0 disable, 1 B1 loop 2 B2 loop, 3 both */
                }
                ret = sf->isac.ctrl(&sf->isac, HW_TESTLOOP, cq->channel);
                break;
+       case MISDN_CTRL_L1_TIMER3:
+               ret = sf->isac.ctrl(&sf->isac, HW_TIMER3_VALUE, cq->p1);
+               break;
        default:
                pr_info("%s: unknown Op %x\n", sf->name, cq->op);
                ret = -EINVAL;
 
 
        switch (cq->op) {
        case MISDN_CTRL_GETOP:
-               cq->op = 0;
+               cq->op = MISDN_CTRL_L1_TIMER3;
+               break;
+       case MISDN_CTRL_L1_TIMER3:
+               ret = l1_event(card->dch.l1, HW_TIMER3_VALUE | (cq->p1 & 0xff));
                break;
        default:
                pr_info("%s: unknown CTRL OP %x\n", card->name, cq->op);
 
        struct FsmInst l1m;
        struct FsmTimer timer;
        int delay;
+       int t3_value;
        struct dchannel *dch;
        dchannel_l1callback *dcb;
 };
 
-#define TIMER3_VALUE 7000
+#define TIMER3_DEFAULT_VALUE   7000
 
 static
 struct Fsm l1fsm_s = {NULL, 0, 0, NULL, NULL};
 {
        struct layer1 *l1 = fi->userdata;
 
-       mISDN_FsmRestartTimer(&l1->timer, TIMER3_VALUE, EV_TIMER3, NULL, 2);
+       mISDN_FsmRestartTimer(&l1->timer, l1->t3_value, EV_TIMER3, NULL, 2);
        test_and_set_bit(FLG_L1_T3RUN, &l1->Flags);
        l1->dcb(l1->dch, HW_RESET_REQ);
 }
                release_l1(l1);
                break;
        default:
+               if ((event & ~HW_TIMER3_VMASK) == HW_TIMER3_VALUE) {
+                       int val = event & HW_TIMER3_VMASK;
+
+                       if (val < 5)
+                               val = 5;
+                       if (val > 30)
+                               val = 30;
+                       l1->t3_value = val;
+                       break;
+               }
                if (*debug & DEBUG_L1)
                        printk(KERN_DEBUG "%s %x unhandled\n",
                               __func__, event);
        nl1->l1m.fsm = &l1fsm_s;
        nl1->l1m.state = ST_L1_F3;
        nl1->Flags = 0;
+       nl1->t3_value = TIMER3_DEFAULT_VALUE;
        nl1->l1m.debug = *debug & DEBUG_L1_FSM;
        nl1->l1m.userdata = nl1;
        nl1->l1m.userint = 0;
 
 #define HW_TESTRX_RAW  0x9602
 #define HW_TESTRX_HDLC 0x9702
 #define HW_TESTRX_OFF  0x9802
+#define HW_TIMER3_IND  0x9902
+#define HW_TIMER3_VALUE        0x9a00
+#define HW_TIMER3_VMASK        0x00FF
 
 struct layer1;
 extern int     l1_event(struct layer1 *, u_int);
 
  */
 #define        MISDN_MAJOR_VERSION     1
 #define        MISDN_MINOR_VERSION     1
-#define MISDN_RELEASE          26
+#define MISDN_RELEASE          27
 
 /* primitives for information exchange
  * generell format
 #define MISDN_CTRL_RX_OFF              0x0100
 #define MISDN_CTRL_FILL_EMPTY          0x0200
 #define MISDN_CTRL_GETPEER             0x0400
+#define MISDN_CTRL_L1_TIMER3           0x0800
 #define MISDN_CTRL_HW_FEATURES_OP      0x2000
 #define MISDN_CTRL_HW_FEATURES         0x2001
 #define MISDN_CTRL_HFC_OP              0x4000