#endif
        {{ 0x00, 0x00}, NULL},
 };
-#define num_valid_msg (sizeof(valid_msg)/sizeof(actcapi_msgdsc))
 #define num_valid_imsg 27 /* MANUFACTURER_IND */
 
 /*
 #ifdef DEBUG_DUMP_SKB
        dump_skb(skb);
 #endif
-       for (i = 0; i < num_valid_msg; i++)
+       for (i = 0; i < ARRAY_SIZE(valid_msg); i++)
                if ((msg->hdr.cmd.cmd == valid_msg[i].cmd.cmd) &&
                    (msg->hdr.cmd.subcmd == valid_msg[i].cmd.subcmd)) {
                        descr = valid_msg[i].description;
 
         0x0200, 0x0240, 0x0280, 0x02c0, 0x0300, 0x0340, 0x0380,
         0xcfe0, 0xcfa0, 0xcf60, 0xcf20, 0xcee0, 0xcea0, 0xce60,
 };
-#define ISA_NRPORTS (sizeof(act2000_isa_ports)/sizeof(unsigned short))
 
 static act2000_card *cards = (act2000_card *) NULL;
 
                 * This may result in more than one card detected.
                 */
                switch (bus) {
-                       case ACT2000_BUS_ISA:
-                               for (i = 0; i < ISA_NRPORTS; i++)
-                                       if (act2000_isa_detect(act2000_isa_ports[i])) {
-                                               printk(KERN_INFO
-                                                      "act2000: Detected ISA card at port 0x%x\n",
-                                                      act2000_isa_ports[i]);
-                                               act2000_alloccard(bus, act2000_isa_ports[i], irq, id);
-                                       }
-                               break;
-                       case ACT2000_BUS_MCA:
-                       case ACT2000_BUS_PCMCIA:
-                       default:
-                               printk(KERN_WARNING
-                                      "act2000: addcard: Invalid BUS type %d\n",
-                                      bus);
+               case ACT2000_BUS_ISA:
+                       for (i = 0; i < ARRAY_SIZE(act2000_isa_ports); i++)
+                               if (act2000_isa_detect(act2000_isa_ports[i])) {
+                                       printk(KERN_INFO "act2000: Detected "
+                                               "ISA card at port 0x%x\n",
+                                               act2000_isa_ports[i]);
+                                       act2000_alloccard(bus,
+                                               act2000_isa_ports[i], irq, id);
+                               }
+                       break;
+               case ACT2000_BUS_MCA:
+               case ACT2000_BUS_PCMCIA:
+               default:
+                       printk(KERN_WARNING
+                               "act2000: addcard: Invalid BUS type %d\n", bus);
                }
        }
        if (!cards)
 
   dbug(1,dprintf("com=%x",msg->header.command));
 
   for(j=0;j<MAX_MSG_PARMS+1;j++) msg_parms[j].length = 0;
-  for(i=0, ret = _BAD_MSG;
-      i<(sizeof(ftable)/sizeof(struct _ftable));
-      i++) {
+  for(i=0, ret = _BAD_MSG; i < ARRAY_SIZE(ftable); i++) {
 
     if(ftable[i].command==msg->header.command) {
       /* break loop if the message is correct, otherwise continue scan  */
 
        diva_os_xdi_adapter_t *diva_current;
        diva_os_xdi_adapter_t *adapter_list[4];
        PISDN_ADAPTER Slave;
-       unsigned long bar_length[sizeof(_4bri_bar_length) /
-                                sizeof(_4bri_bar_length[0])];
+       unsigned long bar_length[ARRAY_SIZE(_4bri_bar_length)];
        int v2 = _4bri_is_rev_2_card(a->CardOrdinal);
        int tasks = _4bri_is_rev_2_bri_card(a->CardOrdinal) ? 1 : MQ_INSTANCE_COUNT;
        int factor = (tasks == 1) ? 1 : 2;
 
 };
 /* *INDENT-ON* */
 
-#define FNCOUNT (sizeof(fnlist)/sizeof(struct FsmNode))
-
 int __init
 CallcNew(void)
 {
        callcfsm.event_count = EVENT_COUNT;
        callcfsm.strEvent = strEvent;
        callcfsm.strState = strState;
-       return FsmNew(&callcfsm, fnlist, FNCOUNT);
+       return FsmNew(&callcfsm, fnlist, ARRAY_SIZE(fnlist));
 }
 
 void
 
        {ST_L1_F8, EV_TIMER_DEACT, l1_timer_deact},
 };
 
-#define L1S_FN_COUNT (sizeof(L1SFnList)/sizeof(struct FsmNode))
-
 #ifdef HISAX_UINTERFACE
 static void
 l1_deact_req_u(struct FsmInst *fi, int event, void *arg)
        {ST_L1_RESET, EV_TIMER_DEACT, l1_timer_deact},
 };
 
-#define L1U_FN_COUNT (sizeof(L1UFnList)/sizeof(struct FsmNode))
-
 #endif
 
 static void
        {ST_L1_WAIT_DEACT, EV_TIMER_DEACT, l1b_timer_deact},
 };
 
-#define L1B_FN_COUNT (sizeof(L1BFnList)/sizeof(struct FsmNode))
-
 int __init 
 Isdnl1New(void)
 {
        l1fsm_s.event_count = L1_EVENT_COUNT;
        l1fsm_s.strEvent = strL1Event;
        l1fsm_s.strState = strL1SState;
-       retval = FsmNew(&l1fsm_s, L1SFnList, L1S_FN_COUNT);
+       retval = FsmNew(&l1fsm_s, L1SFnList, ARRAY_SIZE(L1SFnList));
        if (retval)
                return retval;
 
        l1fsm_b.event_count = L1_EVENT_COUNT;
        l1fsm_b.strEvent = strL1Event;
        l1fsm_b.strState = strL1BState;
-       retval = FsmNew(&l1fsm_b, L1BFnList, L1B_FN_COUNT);
+       retval = FsmNew(&l1fsm_b, L1BFnList, ARRAY_SIZE(L1BFnList));
        if (retval) {
                FsmFree(&l1fsm_s);
                return retval;
        l1fsm_u.event_count = L1_EVENT_COUNT;
        l1fsm_u.strEvent = strL1Event;
        l1fsm_u.strState = strL1UState;
-       retval = FsmNew(&l1fsm_u, L1UFnList, L1U_FN_COUNT);
+       retval = FsmNew(&l1fsm_u, L1UFnList, ARRAY_SIZE(L1UFnList));
        if (retval) {
                FsmFree(&l1fsm_s);
                FsmFree(&l1fsm_b);
 
        {ST_L2_8, EV_L1_DEACTIVATE, l2_persistent_da},
 };
 
-#define L2_FN_COUNT (sizeof(L2FnList)/sizeof(struct FsmNode))
-
 static void
 isdnl2_l1l2(struct PStack *st, int pr, void *arg)
 {
        l2fsm.event_count = L2_EVENT_COUNT;
        l2fsm.strEvent = strL2Event;
        l2fsm.strState = strL2State;
-       return FsmNew(&l2fsm, L2FnList, L2_FN_COUNT);
+       return FsmNew(&l2fsm, L2FnList, ARRAY_SIZE(L2FnList));
 }
 
 void
 
 };
 /* *INDENT-ON* */
 
-#define L3_FN_COUNT (sizeof(L3FnList)/sizeof(struct FsmNode))
-
 void
 l3_msg(struct PStack *st, int pr, void *arg)
 {
        l3fsm.event_count = L3_EVENT_COUNT;
        l3fsm.strEvent = strL3Event;
        l3fsm.strState = strL3State;
-       return FsmNew(&l3fsm, L3FnList, L3_FN_COUNT);
+       return FsmNew(&l3fsm, L3FnList, ARRAY_SIZE(L3FnList));
 }
 
 void
 
         CC_T308_2, l3_1tr6_t308_2},
 };
 
-#define DOWNSTL_LEN \
-       (sizeof(downstl) / sizeof(struct stateentry))
-
 static struct stateentry datastln1[] =
 {
        {SBIT(0),
         MT_N1_REL_ACK, l3_1tr6_rel_ack}
 };
 
-#define DATASTLN1_LEN \
-       (sizeof(datastln1) / sizeof(struct stateentry))
-
 static struct stateentry manstatelist[] =
 {
         {SBIT(2),
          DL_RELEASE | INDICATION, l3_1tr6_dl_release},
 };
  
-#define MANSLLEN \
-        (sizeof(manstatelist) / sizeof(struct stateentry))
 /* *INDENT-ON* */
 
 static void
                                mt = MT_N1_INVALID;
                        }
                }
-               for (i = 0; i < DATASTLN1_LEN; i++)
+               for (i = 0; i < ARRAY_SIZE(datastln1); i++)
                        if ((mt == datastln1[i].primitive) &&
                            ((1 << proc->state) & datastln1[i].state))
                                break;
-               if (i == DATASTLN1_LEN) {
+               if (i == ARRAY_SIZE(datastln1)) {
                        dev_kfree_skb(skb);
                        if (st->l3.debug & L3_DEB_STATE) {
                                sprintf(tmp, "up1tr6%sstate %d mt %x unhandled",
                proc = arg;
        }
 
-       for (i = 0; i < DOWNSTL_LEN; i++)
+       for (i = 0; i < ARRAY_SIZE(downstl); i++)
                if ((pr == downstl[i].primitive) &&
                    ((1 << proc->state) & downstl[i].state))
                        break;
-       if (i == DOWNSTL_LEN) {
+       if (i == ARRAY_SIZE(downstl)) {
                if (st->l3.debug & L3_DEB_STATE) {
                        sprintf(tmp, "down1tr6 state %d prim %d unhandled",
                                proc->state, pr);
                 printk(KERN_ERR "HiSax man1tr6 without proc pr=%04x\n", pr);
                 return;
         }
-        for (i = 0; i < MANSLLEN; i++)
+        for (i = 0; i < ARRAY_SIZE(manstatelist); i++)
                 if ((pr == manstatelist[i].primitive) &&
                     ((1 << proc->state) & manstatelist[i].state))
                         break;
-        if (i == MANSLLEN) {
+        if (i == ARRAY_SIZE(manstatelist)) {
                 if (st->l3.debug & L3_DEB_STATE) {
                         l3_debug(st, "cr %d man1tr6 state %d prim %d unhandled",
                                 proc->callref & 0x7f, proc->state, pr);
 
         CC_T309, l3dss1_dl_release},
 };
 
-#define DOWNSLLEN \
-       (sizeof(downstatelist) / sizeof(struct stateentry))
-
 static struct stateentry datastatelist[] =
 {
        {ALL_STATES,
         MT_RESUME_REJECT, l3dss1_resume_rej},
 };
 
-#define DATASLLEN \
-       (sizeof(datastatelist) / sizeof(struct stateentry))
-
 static struct stateentry globalmes_list[] =
 {
        {ALL_STATES,
         MT_RESTART_ACKNOWLEDGE, l3dss1_restart_ack},
 */
 };
-#define GLOBALM_LEN \
-       (sizeof(globalmes_list) / sizeof(struct stateentry))
 
 static struct stateentry manstatelist[] =
 {
          DL_RELEASE | INDICATION, l3dss1_dl_release},
 };
 
-#define MANSLLEN \
-        (sizeof(manstatelist) / sizeof(struct stateentry))
 /* *INDENT-ON* */
 
 
        struct l3_process *proc = st->l3.global;
 
        proc->callref = skb->data[2]; /* cr flag */
-       for (i = 0; i < GLOBALM_LEN; i++)
+       for (i = 0; i < ARRAY_SIZE(globalmes_list); i++)
                if ((mt == globalmes_list[i].primitive) &&
                    ((1 << proc->state) & globalmes_list[i].state))
                        break;
-       if (i == GLOBALM_LEN) {
+       if (i == ARRAY_SIZE(globalmes_list)) {
                if (st->l3.debug & L3_DEB_STATE) {
                        l3_debug(st, "dss1 global state %d mt %x unhandled",
                                proc->state, mt);
        }
        if ((p = findie(skb->data, skb->len, IE_DISPLAY, 0)) != NULL) 
          l3dss1_deliver_display(proc, pr, p); /* Display IE included */
-       for (i = 0; i < DATASLLEN; i++)
+       for (i = 0; i < ARRAY_SIZE(datastatelist); i++)
                if ((mt == datastatelist[i].primitive) &&
                    ((1 << proc->state) & datastatelist[i].state))
                        break;
-       if (i == DATASLLEN) {
+       if (i == ARRAY_SIZE(datastatelist)) {
                if (st->l3.debug & L3_DEB_STATE) {
                        l3_debug(st, "dss1up%sstate %d mt %#x unhandled",
                                (pr == (DL_DATA | INDICATION)) ? " " : "(broadcast) ",
                return;
        }  
 
-       for (i = 0; i < DOWNSLLEN; i++)
+       for (i = 0; i < ARRAY_SIZE(downstatelist); i++)
                if ((pr == downstatelist[i].primitive) &&
                    ((1 << proc->state) & downstatelist[i].state))
                        break;
-       if (i == DOWNSLLEN) {
+       if (i == ARRAY_SIZE(downstatelist)) {
                if (st->l3.debug & L3_DEB_STATE) {
                        l3_debug(st, "dss1down state %d prim %#x unhandled",
                                proc->state, pr);
                 printk(KERN_ERR "HiSax dss1man without proc pr=%04x\n", pr);
                 return;
         }
-        for (i = 0; i < MANSLLEN; i++)
+        for (i = 0; i < ARRAY_SIZE(manstatelist); i++)
                 if ((pr == manstatelist[i].primitive) &&
                     ((1 << proc->state) & manstatelist[i].state))
                         break;
-        if (i == MANSLLEN) {
+        if (i == ARRAY_SIZE(manstatelist)) {
                 if (st->l3.debug & L3_DEB_STATE) {
                         l3_debug(st, "cr %d dss1man state %d prim %#x unhandled",
                                 proc->callref & 0x7f, proc->state, pr);
 
         CC_TSPID, l3ni1_spid_tout },
 };
 
-#define DOWNSLLEN \
-       (sizeof(downstatelist) / sizeof(struct stateentry))
-
 static struct stateentry datastatelist[] =
 {
        {ALL_STATES,
         MT_RESUME_REJECT, l3ni1_resume_rej},
 };
 
-#define DATASLLEN \
-       (sizeof(datastatelist) / sizeof(struct stateentry))
-
 static struct stateentry globalmes_list[] =
 {
        {ALL_STATES,
        { SBIT( 0 ), MT_DL_ESTABLISHED, l3ni1_spid_send },
        { SBIT( 20 ) | SBIT( 21 ) | SBIT( 22 ), MT_INFORMATION, l3ni1_spid_epid },
 };
-#define GLOBALM_LEN \
-       (sizeof(globalmes_list) / sizeof(struct stateentry))
 
 static struct stateentry manstatelist[] =
 {
          DL_RELEASE | INDICATION, l3ni1_dl_release},
 };
 
-#define MANSLLEN \
-        (sizeof(manstatelist) / sizeof(struct stateentry))
 /* *INDENT-ON* */
 
 
                proc->callref = skb->data[2]; /* cr flag */
        else
                proc->callref = 0;
-       for (i = 0; i < GLOBALM_LEN; i++)
+       for (i = 0; i < ARRAY_SIZE(globalmes_list); i++)
                if ((mt == globalmes_list[i].primitive) &&
                    ((1 << proc->state) & globalmes_list[i].state))
                        break;
-       if (i == GLOBALM_LEN) {
+       if (i == ARRAY_SIZE(globalmes_list)) {
                if (st->l3.debug & L3_DEB_STATE) {
                        l3_debug(st, "ni1 global state %d mt %x unhandled",
                                proc->state, mt);
        }
        if ((p = findie(skb->data, skb->len, IE_DISPLAY, 0)) != NULL) 
          l3ni1_deliver_display(proc, pr, p); /* Display IE included */
-       for (i = 0; i < DATASLLEN; i++)
+       for (i = 0; i < ARRAY_SIZE(datastatelist); i++)
                if ((mt == datastatelist[i].primitive) &&
                    ((1 << proc->state) & datastatelist[i].state))
                        break;
-       if (i == DATASLLEN) {
+       if (i == ARRAY_SIZE(datastatelist)) {
                if (st->l3.debug & L3_DEB_STATE) {
                        l3_debug(st, "ni1up%sstate %d mt %#x unhandled",
                                (pr == (DL_DATA | INDICATION)) ? " " : "(broadcast) ",
                return;
        }  
 
-       for (i = 0; i < DOWNSLLEN; i++)
+       for (i = 0; i < ARRAY_SIZE(downstatelist); i++)
                if ((pr == downstatelist[i].primitive) &&
                    ((1 << proc->state) & downstatelist[i].state))
                        break;
-       if (i == DOWNSLLEN) {
+       if (i == ARRAY_SIZE(downstatelist)) {
                if (st->l3.debug & L3_DEB_STATE) {
                        l3_debug(st, "ni1down state %d prim %#x unhandled",
                                proc->state, pr);
                 printk(KERN_ERR "HiSax ni1man without proc pr=%04x\n", pr);
                 return;
         }
-        for (i = 0; i < MANSLLEN; i++)
+        for (i = 0; i < ARRAY_SIZE(manstatelist); i++)
                 if ((pr == manstatelist[i].primitive) &&
                     ((1 << proc->state) & manstatelist[i].state))
                         break;
-        if (i == MANSLLEN) {
+        if (i == ARRAY_SIZE(manstatelist)) {
                 if (st->l3.debug & L3_DEB_STATE) {
                         l3_debug(st, "cr %d ni1man state %d prim %#x unhandled",
                                 proc->callref & 0x7f, proc->state, pr);
 
        }
 };
 
-#define MTSIZE sizeof(mtlist)/sizeof(struct MessageType)
+#define MTSIZE ARRAY_SIZE(mtlist)
 
 static
 struct MessageType mt_n0[] =
        {MT_N0_CLO_ACK, "CLOse ACKnowledge"}
 };
 
-#define MT_N0_LEN (sizeof(mt_n0) / sizeof(struct MessageType))
+#define MT_N0_LEN ARRAY_SIZE(mt_n0)
 
 static
 struct MessageType mt_n1[] =
        {MT_N1_STAT, "STATus"}
 };
 
-#define MT_N1_LEN (sizeof(mt_n1) / sizeof(struct MessageType))
+#define MT_N1_LEN ARRAY_SIZE(mt_n1)
 
 
 static int
        },
 };
 
-#define CVSIZE sizeof(cvlist)/sizeof(struct CauseValue)
+#define CVSIZE ARRAY_SIZE(cvlist)
 
 static
 int
        {CAUSE_UserInfoDiscarded, "User Info Discarded"}
 };
 
-static int cause_1tr6_len = (sizeof(cause_1tr6) / sizeof(struct MessageType));
+static int cause_1tr6_len = ARRAY_SIZE(cause_1tr6);
 
 static int
 prcause_1tr6(char *dest, u_char * p)
        { 0x96, "Redirection name" },
        { 0x9e, "Text" },
 };
-#define DTAGSIZE sizeof(dtaglist)/sizeof(struct DTag)
+#define DTAGSIZE ARRAY_SIZE(dtaglist)
 
 static int
 disptext_ni1(char *dest, u_char * p)
 };
 
 
-#define IESIZE sizeof(ielist)/sizeof(struct InformationElement)
+#define IESIZE ARRAY_SIZE(ielist)
 
 static
 struct InformationElement ielist_ni1[] = {
 };
 
 
-#define IESIZE_NI1 sizeof(ielist_ni1)/sizeof(struct InformationElement)
+#define IESIZE_NI1 ARRAY_SIZE(ielist_ni1)
 
 static
 struct InformationElement ielist_ni1_cs5[] = {
        { 0x2a, "Display text", disptext_ni1 },
 };
 
-#define IESIZE_NI1_CS5 sizeof(ielist_ni1_cs5)/sizeof(struct InformationElement)
+#define IESIZE_NI1_CS5 ARRAY_SIZE(ielist_ni1_cs5)
 
 static
 struct InformationElement ielist_ni1_cs6[] = {
        { 0x7b, "Call appearance", general_ni1 },
 };
 
-#define IESIZE_NI1_CS6 sizeof(ielist_ni1_cs6)/sizeof(struct InformationElement)
+#define IESIZE_NI1_CS6 ARRAY_SIZE(ielist_ni1_cs6)
 
 static struct InformationElement we_0[] =
 {
        {WE0_userInfo, "User Info", general}
 };
 
-#define WE_0_LEN (sizeof(we_0) / sizeof(struct InformationElement))
+#define WE_0_LEN ARRAY_SIZE(we_0)
 
 static struct InformationElement we_6[] =
 {
        {WE6_statusCalled, "Status Called", general},
        {WE6_addTransAttr, "Additional Transmission Attributes", general}
 };
-#define WE_6_LEN (sizeof(we_6) / sizeof(struct InformationElement))
+#define WE_6_LEN ARRAY_SIZE(we_6)
 
 int
 QuickHex(char *txt, u_char * p, int cnt)
 
        {ST_TEI_IDVERIFY, EV_CHKREQ, tei_id_chk_req},
 };
 
-#define TEI_FN_COUNT (sizeof(TeiFnList)/sizeof(struct FsmNode))
-
 int __init
 TeiNew(void)
 {
        teifsm.event_count = TEI_EVENT_COUNT;
        teifsm.strEvent = strTeiEvent;
        teifsm.strState = strTeiState;
-       return FsmNew(&teifsm, TeiFnList, TEI_FN_COUNT);
+       return FsmNew(&teifsm, TeiFnList, ARRAY_SIZE(TeiFnList));
 }
 
 void
 
        {ST_L2_8, EV_L1_DEACTIVATE, l2_persistant_da},
 };
 
-#define L2_FN_COUNT (sizeof(L2FnList)/sizeof(struct FsmNode))
-
 static int
 ph_data_indication(struct layer2 *l2, struct mISDNhead *hh, struct sk_buff *skb)
 {