#define LMI_ANSI_LENGTH                  14
 
 
-typedef struct {
+struct fr_hdr {
 #if defined(__LITTLE_ENDIAN_BITFIELD)
        unsigned ea1:   1;
        unsigned cr:    1;
        unsigned de:    1;
        unsigned ea2:   1;
 #endif
-}__packed fr_hdr;
+} __packed;
 
 
-typedef struct pvc_device_struct {
+struct pvc_device {
        struct net_device *frad;
        struct net_device *main;
        struct net_device *ether;       /* bridged Ethernet interface   */
-       struct pvc_device_struct *next; /* Sorted in ascending DLCI order */
+       struct pvc_device *next;        /* Sorted in ascending DLCI order */
        int dlci;
        int open_count;
 
                unsigned int becn: 1;
                unsigned int bandwidth; /* Cisco LMI reporting only */
        }state;
-}pvc_device;
+};
 
 struct frad_state {
        fr_proto settings;
-       pvc_device *first_pvc;
+       struct pvc_device *first_pvc;
        int dce_pvc_count;
 
        struct timer_list timer;
 }
 
 
-static inline pvc_device* find_pvc(hdlc_device *hdlc, u16 dlci)
+static inline struct pvc_device *find_pvc(hdlc_device *hdlc, u16 dlci)
 {
-       pvc_device *pvc = state(hdlc)->first_pvc;
+       struct pvc_device *pvc = state(hdlc)->first_pvc;
 
        while (pvc) {
                if (pvc->dlci == dlci)
 }
 
 
-static pvc_device* add_pvc(struct net_device *dev, u16 dlci)
+static struct pvc_device *add_pvc(struct net_device *dev, u16 dlci)
 {
        hdlc_device *hdlc = dev_to_hdlc(dev);
-       pvc_device *pvc, **pvc_p = &state(hdlc)->first_pvc;
+       struct pvc_device *pvc, **pvc_p = &state(hdlc)->first_pvc;
 
        while (*pvc_p) {
                if ((*pvc_p)->dlci == dlci)
                pvc_p = &(*pvc_p)->next;
        }
 
-       pvc = kzalloc(sizeof(pvc_device), GFP_ATOMIC);
+       pvc = kzalloc(sizeof(*pvc), GFP_ATOMIC);
 #ifdef DEBUG_PVC
        printk(KERN_DEBUG "add_pvc: allocated pvc %p, frad %p\n", pvc, dev);
 #endif
 }
 
 
-static inline int pvc_is_used(pvc_device *pvc)
+static inline int pvc_is_used(struct pvc_device *pvc)
 {
        return pvc->main || pvc->ether;
 }
 
 
-static inline void pvc_carrier(int on, pvc_device *pvc)
+static inline void pvc_carrier(int on, struct pvc_device *pvc)
 {
        if (on) {
                if (pvc->main)
 
 static inline void delete_unused_pvcs(hdlc_device *hdlc)
 {
-       pvc_device **pvc_p = &state(hdlc)->first_pvc;
+       struct pvc_device **pvc_p = &state(hdlc)->first_pvc;
 
        while (*pvc_p) {
                if (!pvc_is_used(*pvc_p)) {
-                       pvc_device *pvc = *pvc_p;
+                       struct pvc_device *pvc = *pvc_p;
 #ifdef DEBUG_PVC
                        printk(KERN_DEBUG "freeing unused pvc: %p\n", pvc);
 #endif
 }
 
 
-static inline struct net_device** get_dev_p(pvc_device *pvc, int type)
+static inline struct net_device **get_dev_p(struct pvc_device *pvc,
+                                           int type)
 {
        if (type == ARPHRD_ETHER)
                return &pvc->ether;
 
 static int pvc_open(struct net_device *dev)
 {
-       pvc_device *pvc = dev->ml_priv;
+       struct pvc_device *pvc = dev->ml_priv;
 
        if ((pvc->frad->flags & IFF_UP) == 0)
                return -EIO;  /* Frad must be UP in order to activate PVC */
 
 static int pvc_close(struct net_device *dev)
 {
-       pvc_device *pvc = dev->ml_priv;
+       struct pvc_device *pvc = dev->ml_priv;
 
        if (--pvc->open_count == 0) {
                hdlc_device *hdlc = dev_to_hdlc(pvc->frad);
 
 static int pvc_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
 {
-       pvc_device *pvc = dev->ml_priv;
+       struct pvc_device *pvc = dev->ml_priv;
        fr_proto_pvc_info info;
 
        if (ifr->ifr_settings.type == IF_GET_PROTO) {
 
 static netdev_tx_t pvc_xmit(struct sk_buff *skb, struct net_device *dev)
 {
-       pvc_device *pvc = dev->ml_priv;
+       struct pvc_device *pvc = dev->ml_priv;
 
        if (pvc->state.active) {
                if (dev->type == ARPHRD_ETHER) {
        return NETDEV_TX_OK;
 }
 
-static inline void fr_log_dlci_active(pvc_device *pvc)
+static inline void fr_log_dlci_active(struct pvc_device *pvc)
 {
        netdev_info(pvc->frad, "DLCI %d [%s%s%s]%s %s\n",
                    pvc->dlci,
 {
        hdlc_device *hdlc = dev_to_hdlc(dev);
        struct sk_buff *skb;
-       pvc_device *pvc = state(hdlc)->first_pvc;
+       struct pvc_device *pvc = state(hdlc)->first_pvc;
        int lmi = state(hdlc)->settings.lmi;
        int dce = state(hdlc)->settings.dce;
        int len = lmi == LMI_ANSI ? LMI_ANSI_LENGTH : LMI_CCITT_CISCO_LENGTH;
 static void fr_set_link_state(int reliable, struct net_device *dev)
 {
        hdlc_device *hdlc = dev_to_hdlc(dev);
-       pvc_device *pvc = state(hdlc)->first_pvc;
+       struct pvc_device *pvc = state(hdlc)->first_pvc;
 
        state(hdlc)->reliable = reliable;
        if (reliable) {
 static int fr_lmi_recv(struct net_device *dev, struct sk_buff *skb)
 {
        hdlc_device *hdlc = dev_to_hdlc(dev);
-       pvc_device *pvc;
+       struct pvc_device *pvc;
        u8 rxseq, txseq;
        int lmi = state(hdlc)->settings.lmi;
        int dce = state(hdlc)->settings.dce;
 {
        struct net_device *frad = skb->dev;
        hdlc_device *hdlc = dev_to_hdlc(frad);
-       fr_hdr *fh = (fr_hdr*)skb->data;
+       struct fr_hdr *fh = (struct fr_hdr *)skb->data;
        u8 *data = skb->data;
        u16 dlci;
-       pvc_device *pvc;
+       struct pvc_device *pvc;
        struct net_device *dev = NULL;
 
        if (skb->len <= 4 || fh->ea1 || data[2] != FR_UI)
 static void fr_close(struct net_device *dev)
 {
        hdlc_device *hdlc = dev_to_hdlc(dev);
-       pvc_device *pvc = state(hdlc)->first_pvc;
+       struct pvc_device *pvc = state(hdlc)->first_pvc;
 
        while (pvc) {           /* Shutdown all PVCs for this FRAD */
                if (pvc->main)
 static int fr_add_pvc(struct net_device *frad, unsigned int dlci, int type)
 {
        hdlc_device *hdlc = dev_to_hdlc(frad);
-       pvc_device *pvc;
+       struct pvc_device *pvc;
        struct net_device *dev;
        int used;
 
 
 static int fr_del_pvc(hdlc_device *hdlc, unsigned int dlci, int type)
 {
-       pvc_device *pvc;
+       struct pvc_device *pvc;
        struct net_device *dev;
 
        if ((pvc = find_pvc(hdlc, dlci)) == NULL)
 static void fr_destroy(struct net_device *frad)
 {
        hdlc_device *hdlc = dev_to_hdlc(frad);
-       pvc_device *pvc = state(hdlc)->first_pvc;
+       struct pvc_device *pvc = state(hdlc)->first_pvc;
        state(hdlc)->first_pvc = NULL; /* All PVCs destroyed */
        state(hdlc)->dce_pvc_count = 0;
        state(hdlc)->dce_changed = 1;
 
        while (pvc) {
-               pvc_device *next = pvc->next;
+               struct pvc_device *next = pvc->next;
                /* destructors will free_netdev() main and ether */
                if (pvc->main)
                        unregister_netdevice(pvc->main);