hisax_b_sched_event(bcs, B_RCVBUFREADY);
                break;
        case PH_DATA | CONFIRM:
-               bcs->tx_cnt -= (int) arg;
+               bcs->tx_cnt -= (long)arg;
                if (test_bit(FLG_LLI_L1WAKEUP,&bcs->st->lli.flag)) {
                        u_long  flags;
                        spin_lock_irqsave(&bcs->aclock, flags);
-                       bcs->ackcnt += (int) arg;
+                       bcs->ackcnt += (long)arg;
                        spin_unlock_irqrestore(&bcs->aclock, flags);
                        schedule_event(bcs, B_ACKPENDING);
                }
 
        switch (pr) {
        case PH_ACTIVATE | REQUEST:
-               B_L2L1(b_if, pr, (void *) st->l1.mode);
+               B_L2L1(b_if, pr, (void *)(unsigned long)st->l1.mode);
                break;
        case PH_DATA | REQUEST:
        case PH_PULL | INDICATION:
 
        struct hfc4s8s_btype *bch = ifc->priv;
        struct hfc4s8s_l1 *l1 = bch->l1p;
        struct sk_buff *skb = (struct sk_buff *) arg;
-       int mode = (int) arg;
+       long mode = (long) arg;
        u_long flags;
 
        switch (pr) {
        struct sk_buff *skb;
        u_char f1, f2;
        u_char *cp;
-       int cnt;
+       long cnt;
 
        if (l1p->l1_state != 7)
                return;
        struct sk_buff *skb;
        struct hfc4s8s_l1 *l1 = bch->l1p;
        u_char *cp;
-       int cnt, max, hdlc_num, ack_len = 0;
+       int cnt, max, hdlc_num;
+       long ack_len = 0;
 
        if (!l1->enabled || (bch->mode == L1_MODE_NULL))
                return;
 
                        break;
                case (HW_TESTLOOP | REQUEST):
                        spin_lock_irqsave(&cs->lock, flags);
-                       switch ((int) arg) {
+                       switch ((long) arg) {
                                case (1):
                                        Write_hfc(cs, HFCSX_B1_SSL, 0x80);      /* tx slot */
                                        Write_hfc(cs, HFCSX_B1_RSL, 0x80);      /* rx slot */
                                default:
                                        spin_unlock_irqrestore(&cs->lock, flags);
                                        if (cs->debug & L1_DEB_WARN)
-                                               debugl1(cs, "hfcsx_l1hw loop invalid %4x", (int) arg);
+                                               debugl1(cs, "hfcsx_l1hw loop invalid %4lx", arg);
                                        return;
                        }
                        cs->hw.hfcsx.trm |= 0x80;       /* enable IOM-loop */
 
                                fifo->delete_flg = TRUE;
                                fifo->hif->l1l2(fifo->hif,
                                                PH_DATA | CONFIRM,
-                                               (void *) fifo->skbuff->
+                                               (void *) (unsigned long) fifo->skbuff->
                                                truesize);
                                if (fifo->skbuff && fifo->delete_flg) {
                                        dev_kfree_skb_any(fifo->skbuff);
                                set_hfcmode(hfc,
                                            (fifo->fifonum ==
                                             HFCUSB_B1_TX) ? 0 : 1,
-                                           (int) arg);
+                                           (long) arg);
                                fifo->hif->l1l2(fifo->hif,
                                                PH_ACTIVATE | INDICATION,
                                                NULL);
 
        }
        bcs->tx_cnt = 0;
        bcs->tx_skb = NULL;
-       B_L1L2(bcs, PH_DATA | CONFIRM, (void *) skb->truesize);
+       B_L1L2(bcs, PH_DATA | CONFIRM, (void *)(unsigned long)skb->truesize);
        dev_kfree_skb_irq(skb);
 }
 
                hdlc_fill_fifo(bcs);
                break;
        case PH_ACTIVATE | REQUEST:
-               mode = (int) arg;
+               mode = (long) arg;
                DBG(4,"B%d,PH_ACTIVATE_REQUEST %d", bcs->channel + 1, mode);
                modehdlc(bcs, mode);
                B_L1L2(bcs, PH_ACTIVATE | INDICATION, NULL);
 
        retval = pci_register_driver(&fcpci_driver);
        if (retval)
-               goto out;
+               return retval;
 #ifdef __ISAPNP__
        retval = pnp_register_driver(&fcpnp_driver);
-       if (retval < 0)
-               goto out_unregister_pci;
+       if (retval < 0) {
+               pci_unregister_driver(&fcpci_driver);
+               return retval;
+       }
 #endif
        return 0;
-
- out_unregister_pci:
-       pci_unregister_driver(&fcpci_driver);
- out:
-       return retval;
 }
 
 static void __exit hisax_fcpcipnp_exit(void)
 
                        if (!skb->len) {
                                // Frame sent
                                b_out->tx_skb = NULL;
-                               B_L1L2(bcs, PH_DATA | CONFIRM, (void *) skb->truesize);
+                               B_L1L2(bcs, PH_DATA | CONFIRM, (void *)(unsigned long) skb->truesize);
                                dev_kfree_skb_any(skb);
 
 /*                             if (!(bcs->tx_skb = skb_dequeue(&bcs->sq))) { */
 {
        struct st5481_bcs *bcs = ifc->priv;
        struct sk_buff *skb = arg;
-       int mode;
+       long mode;
 
        DBG(4, "");
 
                bcs->b_out.tx_skb = skb;
                break;
        case PH_ACTIVATE | REQUEST:
-               mode = (int) arg;
-               DBG(4,"B%d,PH_ACTIVATE_REQUEST %d", bcs->channel + 1, mode);
+               mode = (long) arg;
+               DBG(4,"B%d,PH_ACTIVATE_REQUEST %ld", bcs->channel + 1, mode);
                st5481B_mode(bcs, mode);
                B_L1L2(bcs, PH_ACTIVATE | INDICATION, NULL);
                break;
 
 {
        struct st5481_adapter *adapter = urb->context;
        struct st5481_d_out *d_out = &adapter->d_out;
-       int buf_nr;
+       long buf_nr;
        
        DBG(2, "");
 
 static void dout_complete(struct FsmInst *fsm, int event, void *arg)
 {
        struct st5481_adapter *adapter = fsm->userdata;
-       int buf_nr = (int) arg;
+       long buf_nr = (long) arg;
 
        usb_d_out(adapter, buf_nr);
 }