]> nv-tegra.nvidia Code Review - linux-2.6.git/commitdiff
Merge branch 'upstream-linus' of master.kernel.org:/pub/scm/linux/kernel/git/jgarzik...
authorLinus Torvalds <torvalds@g5.osdl.org>
Sat, 21 Oct 2006 20:40:29 +0000 (13:40 -0700)
committerLinus Torvalds <torvalds@g5.osdl.org>
Sat, 21 Oct 2006 20:40:29 +0000 (13:40 -0700)
* 'upstream-linus' of master.kernel.org:/pub/scm/linux/kernel/git/jgarzik/netdev-2.6: (22 commits)
  [PATCH] ibmveth: Fix index increment calculation
  [PATCH] Fix timer race
  [PATCH] Remove useless comment from sb1250
  [PATCH] ucc_geth: changes to ucc_geth driver as a result of qe_lib changes and bugfixes
  [PATCH] sky2: 88E803X transmit lockup
  [PATCH] e1000: Reset all functions after a PCI error
  [PATCH] WAN/pc300: handle, propagate minor errors
  [PATCH] Update smc91x driver with ARM Versatile board info
  [PATCH] wireless: WE-20 compatibility for ESSID and NICKN ioctls
  [PATCH] zd1211rw: fix build-break caused by association race fix
  [PATCH] sotftmac: fix a slab corruption in WEP restricted key association
  [PATCH] airo: check if need to freeze
  [PATCH] wireless: More WE-21 potential overflows...
  [PATCH] zd1201: Possible NULL dereference
  [PATCH] orinoco: fix WE-21 buffer overflow
  [PATCH] airo.c: check returned values
  [PATCH] bcm43xx-softmac: Fix system hang for x86-64 with >1GB RAM
  [PATCH] bcm43xx-softmac: check returned value from pci_enable_device
  [PATCH] softmac: Fix WX and association related races
  [PATCH] bcm43xx: fix race condition in periodic work handler
  ...

29 files changed:
drivers/net/Kconfig
drivers/net/e1000/e1000_main.c
drivers/net/ioc3-eth.c
drivers/net/r8169.c
drivers/net/sb1250-mac.c
drivers/net/sky2.c
drivers/net/smc91x.h
drivers/net/ucc_geth.c
drivers/net/ucc_geth.h
drivers/net/ucc_geth_phy.c
drivers/net/ucc_geth_phy.h
drivers/net/wan/pc300_drv.c
drivers/net/wireless/airo.c
drivers/net/wireless/atmel.c
drivers/net/wireless/bcm43xx/bcm43xx_dma.c
drivers/net/wireless/bcm43xx/bcm43xx_dma.h
drivers/net/wireless/bcm43xx/bcm43xx_leds.c
drivers/net/wireless/bcm43xx/bcm43xx_main.c
drivers/net/wireless/bcm43xx/bcm43xx_wx.c
drivers/net/wireless/orinoco.c
drivers/net/wireless/ray_cs.c
drivers/net/wireless/zd1201.c
drivers/net/wireless/zd1211rw/zd_mac.c
include/net/ieee80211softmac.h
net/core/wireless.c
net/ieee80211/softmac/ieee80211softmac_assoc.c
net/ieee80211/softmac/ieee80211softmac_io.c
net/ieee80211/softmac/ieee80211softmac_module.c
net/ieee80211/softmac/ieee80211softmac_wx.c

index ab92cc794c64d85363b98d1bf3aa76585c68ccc8..e2ed24918a589fd7f0d0414597f8cc974a4d48fc 100644 (file)
@@ -2288,7 +2288,7 @@ config UGETH_TX_ON_DEMOND
 
 config UGETH_HAS_GIGA
        bool
-       depends on UCC_GETH && MPC836x
+       depends on UCC_GETH && PPC_MPC836x
 
 config MV643XX_ETH
        tristate "MV-643XX Ethernet support"
index ce0d35fe3947ecde15afea7cd56d77bbc8577e7a..fa849831d0998ead7db0fbe09f6b20c5398a0018 100644 (file)
@@ -4914,10 +4914,6 @@ static pci_ers_result_t e1000_io_slot_reset(struct pci_dev *pdev)
        pci_enable_wake(pdev, PCI_D3hot, 0);
        pci_enable_wake(pdev, PCI_D3cold, 0);
 
-       /* Perform card reset only on one instance of the card */
-       if (PCI_FUNC (pdev->devfn) != 0)
-               return PCI_ERS_RESULT_RECOVERED;
-
        e1000_reset(adapter);
        E1000_WRITE_REG(&adapter->hw, WUS, ~0);
 
index e963dbf816bef71bc99f9dbbb637a070182e9a15..f56b00ee385e339198e950e060558dcba9418788 100644 (file)
@@ -1017,7 +1017,7 @@ static void ioc3_init(struct net_device *dev)
        struct ioc3_private *ip = netdev_priv(dev);
        struct ioc3 *ioc3 = ip->regs;
 
-       del_timer(&ip->ioc3_timer);             /* Kill if running      */
+       del_timer_sync(&ip->ioc3_timer);        /* Kill if running      */
 
        ioc3_w_emcr(EMCR_RST);                  /* Reset                */
        (void) ioc3_r_emcr();                   /* Flush WB             */
@@ -1081,7 +1081,7 @@ static int ioc3_close(struct net_device *dev)
 {
        struct ioc3_private *ip = netdev_priv(dev);
 
-       del_timer(&ip->ioc3_timer);
+       del_timer_sync(&ip->ioc3_timer);
 
        netif_stop_queue(dev);
 
index f1c75751cab7a4a55e7ba3c6a0800bd50874ef4a..d132fe7d475e99afe10d73cc02963923c1efadbc 100644 (file)
@@ -214,6 +214,7 @@ static struct pci_device_id rtl8169_pci_tbl[] = {
        { PCI_DEVICE(PCI_VENDOR_ID_REALTEK,     0x8168), 0, 0, RTL_CFG_2 },
        { PCI_DEVICE(PCI_VENDOR_ID_REALTEK,     0x8169), 0, 0, RTL_CFG_0 },
        { PCI_DEVICE(PCI_VENDOR_ID_DLINK,       0x4300), 0, 0, RTL_CFG_0 },
+       { PCI_DEVICE(0x1259,                    0xc107), 0, 0, RTL_CFG_0 },
        { PCI_DEVICE(0x16ec,                    0x0116), 0, 0, RTL_CFG_0 },
        { PCI_VENDOR_ID_LINKSYS,                0x1032,
                PCI_ANY_ID, 0x0024, 0, 0, RTL_CFG_0 },
@@ -2700,6 +2701,7 @@ static void rtl8169_down(struct net_device *dev)
        struct rtl8169_private *tp = netdev_priv(dev);
        void __iomem *ioaddr = tp->mmio_addr;
        unsigned int poll_locked = 0;
+       unsigned int intrmask;
 
        rtl8169_delete_timer(dev);
 
@@ -2738,8 +2740,11 @@ core_down:
         * 2) dev->change_mtu
         *    -> rtl8169_poll can not be issued again and re-enable the
         *       interruptions. Let's simply issue the IRQ down sequence again.
+        *
+        * No loop if hotpluged or major error (0xffff).
         */
-       if (RTL_R16(IntrMask))
+       intrmask = RTL_R16(IntrMask);
+       if (intrmask && (intrmask != 0xffff))
                goto core_down;
 
        rtl8169_tx_clear(tp);
index db2324939b69ec7fef2bad39e7be0cfa62d5af72..1eae16b72b4b71122c47284d9a3902af2c63485e 100644 (file)
@@ -2903,7 +2903,7 @@ sbmac_init_module(void)
 
                dev = alloc_etherdev(sizeof(struct sbmac_softc));
                if (!dev)
-                       return -ENOMEM; /* return ENOMEM */
+                       return -ENOMEM;
 
                printk(KERN_DEBUG "sbmac: configuring MAC at %lx\n", port);
 
index 67ecd66f26d6cee6c265fa148df05023eeaaa7f9..95efdb5bbbe10da3a1932c3614d09ce85cadda09 100644 (file)
@@ -699,16 +699,10 @@ static void sky2_mac_init(struct sky2_hw *hw, unsigned port)
 
 }
 
-/* Assign Ram Buffer allocation.
- * start and end are in units of 4k bytes
- * ram registers are in units of 64bit words
- */
-static void sky2_ramset(struct sky2_hw *hw, u16 q, u8 startk, u8 endk)
+/* Assign Ram Buffer allocation in units of 64bit (8 bytes) */
+static void sky2_ramset(struct sky2_hw *hw, u16 q, u32 start, u32 end)
 {
-       u32 start, end;
-
-       start = startk * 4096/8;
-       end = (endk * 4096/8) - 1;
+       pr_debug(PFX "q %d %#x %#x\n", q, start, end);
 
        sky2_write8(hw, RB_ADDR(q, RB_CTRL), RB_RST_CLR);
        sky2_write32(hw, RB_ADDR(q, RB_START), start);
@@ -717,7 +711,7 @@ static void sky2_ramset(struct sky2_hw *hw, u16 q, u8 startk, u8 endk)
        sky2_write32(hw, RB_ADDR(q, RB_RP), start);
 
        if (q == Q_R1 || q == Q_R2) {
-               u32 space = (endk - startk) * 4096/8;
+               u32 space = end - start + 1;
                u32 tp = space - space/4;
 
                /* On receive queue's set the thresholds
@@ -1199,19 +1193,16 @@ static int sky2_up(struct net_device *dev)
 
        sky2_mac_init(hw, port);
 
-       /* Determine available ram buffer space (in 4K blocks).
-        * Note: not sure about the FE setting below yet
-        */
-       if (hw->chip_id == CHIP_ID_YUKON_FE)
-               ramsize = 4;
-       else
-               ramsize = sky2_read8(hw, B2_E_0);
+       /* Determine available ram buffer space in qwords.  */
+       ramsize = sky2_read8(hw, B2_E_0) * 4096/8;
 
-       /* Give transmitter one third (rounded up) */
-       rxspace = ramsize - (ramsize + 2) / 3;
+       if (ramsize > 6*1024/8)
+               rxspace = ramsize - (ramsize + 2) / 3;
+       else
+               rxspace = ramsize / 2;
 
-       sky2_ramset(hw, rxqaddr[port], 0, rxspace);
-       sky2_ramset(hw, txqaddr[port], rxspace, ramsize);
+       sky2_ramset(hw, rxqaddr[port], 0, rxspace-1);
+       sky2_ramset(hw, txqaddr[port], rxspace, ramsize-1);
 
        /* Make sure SyncQ is disabled */
        sky2_write8(hw, RB_ADDR(port == 0 ? Q_XS1 : Q_XS2, RB_CTRL),
index 0c9f1e7dab2e8de01277bef61c3f7b072792ca9b..a8640169fc77afede8c7f28376ccc8967b214668 100644 (file)
@@ -416,6 +416,24 @@ static inline void LPD7_SMC_outsw (unsigned char* a, int r,
 
 #define SMC_IRQ_FLAGS          (0)
 
+#elif  defined(CONFIG_ARCH_VERSATILE)
+
+#define SMC_CAN_USE_8BIT       1
+#define SMC_CAN_USE_16BIT      1
+#define SMC_CAN_USE_32BIT      1
+#define SMC_NOWAIT             1
+
+#define SMC_inb(a, r)          readb((a) + (r))
+#define SMC_inw(a, r)          readw((a) + (r))
+#define SMC_inl(a, r)          readl((a) + (r))
+#define SMC_outb(v, a, r)      writeb(v, (a) + (r))
+#define SMC_outw(v, a, r)      writew(v, (a) + (r))
+#define SMC_outl(v, a, r)      writel(v, (a) + (r))
+#define SMC_insl(a, r, p, l)   readsl((a) + (r), p, l)
+#define SMC_outsl(a, r, p, l)  writesl((a) + (r), p, l)
+
+#define SMC_IRQ_FLAGS          (0)
+
 #else
 
 #define SMC_CAN_USE_8BIT       1
index 12cd7b561f35aba401769575f34d17a13883c32e..b37888011067f2711b8b954213a7e86243ac788c 100644 (file)
@@ -2,14 +2,11 @@
  * Copyright (C) Freescale Semicondutor, Inc. 2006. All rights reserved.
  *
  * Author: Shlomi Gridish <gridish@freescale.com>
+ *        Li Yang <leoli@freescale.com>
  *
  * Description:
  * QE UCC Gigabit Ethernet Driver
  *
- * Changelog:
- * Jul 6, 2006 Li Yang <LeoLi@freescale.com>
- * - Rearrange code and style fixes
- *
  * This program is free software; you can redistribute  it and/or modify it
  * under  the terms of  the GNU General  Public License as published by the
  * Free Software Foundation;  either version 2 of the  License, or (at your
@@ -31,9 +28,9 @@
 #include <linux/dma-mapping.h>
 #include <linux/fsl_devices.h>
 #include <linux/ethtool.h>
-#include <linux/platform_device.h>
 #include <linux/mii.h>
 
+#include <asm/of_device.h>
 #include <asm/uaccess.h>
 #include <asm/irq.h>
 #include <asm/io.h>
@@ -70,7 +67,7 @@
 
 static DEFINE_SPINLOCK(ugeth_lock);
 
-static ucc_geth_info_t ugeth_primary_info = {
+static struct ucc_geth_info ugeth_primary_info = {
        .uf_info = {
                    .bd_mem_part = MEM_PART_SYSTEM,
                    .rtsm = UCC_FAST_SEND_IDLES_BETWEEN_FRAMES,
@@ -163,7 +160,7 @@ static ucc_geth_info_t ugeth_primary_info = {
        .riscRx = QE_RISC_ALLOCATION_RISC1_AND_RISC2,
 };
 
-static ucc_geth_info_t ugeth_info[8];
+static struct ucc_geth_info ugeth_info[8];
 
 #ifdef DEBUG
 static void mem_disp(u8 *addr, int size)
@@ -219,8 +216,8 @@ static struct list_head *dequeue(struct list_head *lh)
        }
 }
 
-static int get_interface_details(enet_interface_e enet_interface,
-                                enet_speed_e *speed,
+static int get_interface_details(enum enet_interface enet_interface,
+                                enum enet_speed *speed,
                                 int *r10m,
                                 int *rmm,
                                 int *rpm,
@@ -283,7 +280,7 @@ static int get_interface_details(enet_interface_e enet_interface,
        return 0;
 }
 
-static struct sk_buff *get_new_skb(ucc_geth_private_t *ugeth, u8 *bd)
+static struct sk_buff *get_new_skb(struct ucc_geth_private *ugeth, u8 *bd)
 {
        struct sk_buff *skb = NULL;
 
@@ -303,21 +300,19 @@ static struct sk_buff *get_new_skb(ucc_geth_private_t *ugeth, u8 *bd)
 
        skb->dev = ugeth->dev;
 
-       BD_BUFFER_SET(bd,
+       out_be32(&((struct qe_bd *)bd)->buf,
                      dma_map_single(NULL,
                                     skb->data,
                                     ugeth->ug_info->uf_info.max_rx_buf_length +
                                     UCC_GETH_RX_DATA_BUF_ALIGNMENT,
                                     DMA_FROM_DEVICE));
 
-       BD_STATUS_AND_LENGTH_SET(bd,
-                                (R_E | R_I |
-                                 (BD_STATUS_AND_LENGTH(bd) & R_W)));
+       out_be32((u32 *)bd, (R_E | R_I | (in_be32((u32 *)bd) & R_W)));
 
        return skb;
 }
 
-static int rx_bd_buffer_set(ucc_geth_private_t *ugeth, u8 rxQ)
+static int rx_bd_buffer_set(struct ucc_geth_private *ugeth, u8 rxQ)
 {
        u8 *bd;
        u32 bd_status;
@@ -328,7 +323,7 @@ static int rx_bd_buffer_set(ucc_geth_private_t *ugeth, u8 rxQ)
        i = 0;
 
        do {
-               bd_status = BD_STATUS_AND_LENGTH(bd);
+               bd_status = in_be32((u32*)bd);
                skb = get_new_skb(ugeth, bd);
 
                if (!skb)       /* If can not allocate data buffer,
@@ -338,19 +333,19 @@ static int rx_bd_buffer_set(ucc_geth_private_t *ugeth, u8 rxQ)
                ugeth->rx_skbuff[rxQ][i] = skb;
 
                /* advance the BD pointer */
-               bd += UCC_GETH_SIZE_OF_BD;
+               bd += sizeof(struct qe_bd);
                i++;
        } while (!(bd_status & R_W));
 
        return 0;
 }
 
-static int fill_init_enet_entries(ucc_geth_private_t *ugeth,
+static int fill_init_enet_entries(struct ucc_geth_private *ugeth,
                                  volatile u32 *p_start,
                                  u8 num_entries,
                                  u32 thread_size,
                                  u32 thread_alignment,
-                                 qe_risc_allocation_e risc,
+                                 enum qe_risc_allocation risc,
                                  int skip_page_for_first_entry)
 {
        u32 init_enet_offset;
@@ -383,10 +378,10 @@ static int fill_init_enet_entries(ucc_geth_private_t *ugeth,
        return 0;
 }
 
-static int return_init_enet_entries(ucc_geth_private_t *ugeth,
+static int return_init_enet_entries(struct ucc_geth_private *ugeth,
                                    volatile u32 *p_start,
                                    u8 num_entries,
-                                   qe_risc_allocation_e risc,
+                                   enum qe_risc_allocation risc,
                                    int skip_page_for_first_entry)
 {
        u32 init_enet_offset;
@@ -416,11 +411,11 @@ static int return_init_enet_entries(ucc_geth_private_t *ugeth,
 }
 
 #ifdef DEBUG
-static int dump_init_enet_entries(ucc_geth_private_t *ugeth,
+static int dump_init_enet_entries(struct ucc_geth_private *ugeth,
                                  volatile u32 *p_start,
                                  u8 num_entries,
                                  u32 thread_size,
-                                 qe_risc_allocation_e risc,
+                                 enum qe_risc_allocation risc,
                                  int skip_page_for_first_entry)
 {
        u32 init_enet_offset;
@@ -456,14 +451,14 @@ static int dump_init_enet_entries(ucc_geth_private_t *ugeth,
 #endif
 
 #ifdef CONFIG_UGETH_FILTERING
-static enet_addr_container_t *get_enet_addr_container(void)
+static struct enet_addr_container *get_enet_addr_container(void)
 {
-       enet_addr_container_t *enet_addr_cont;
+       struct enet_addr_container *enet_addr_cont;
 
        /* allocate memory */
-       enet_addr_cont = kmalloc(sizeof(enet_addr_container_t), GFP_KERNEL);
+       enet_addr_cont = kmalloc(sizeof(struct enet_addr_container), GFP_KERNEL);
        if (!enet_addr_cont) {
-               ugeth_err("%s: No memory for enet_addr_container_t object.",
+               ugeth_err("%s: No memory for enet_addr_container object.",
                          __FUNCTION__);
                return NULL;
        }
@@ -472,45 +467,43 @@ static enet_addr_container_t *get_enet_addr_container(void)
 }
 #endif /* CONFIG_UGETH_FILTERING */
 
-static void put_enet_addr_container(enet_addr_container_t *enet_addr_cont)
+static void put_enet_addr_container(struct enet_addr_container *enet_addr_cont)
 {
        kfree(enet_addr_cont);
 }
 
+static int set_mac_addr(__be16 __iomem *reg, u8 *mac)
+{
+       out_be16(&reg[0], ((u16)mac[5] << 8) | mac[4]);
+       out_be16(&reg[1], ((u16)mac[3] << 8) | mac[2]);
+       out_be16(&reg[2], ((u16)mac[1] << 8) | mac[0]);
+}
+
 #ifdef CONFIG_UGETH_FILTERING
-static int hw_add_addr_in_paddr(ucc_geth_private_t *ugeth,
-                               enet_addr_t *p_enet_addr, u8 paddr_num)
+static int hw_add_addr_in_paddr(struct ucc_geth_private *ugeth,
+                                u8 *p_enet_addr, u8 paddr_num)
 {
-       ucc_geth_82xx_address_filtering_pram_t *p_82xx_addr_filt;
+       struct ucc_geth_82xx_address_filtering_pram *p_82xx_addr_filt;
 
        if (!(paddr_num < NUM_OF_PADDRS)) {
-               ugeth_warn("%s: Illagel paddr_num.", __FUNCTION__);
+               ugeth_warn("%s: Illegal paddr_num.", __FUNCTION__);
                return -EINVAL;
        }
 
        p_82xx_addr_filt =
-           (ucc_geth_82xx_address_filtering_pram_t *) ugeth->p_rx_glbl_pram->
+           (struct ucc_geth_82xx_address_filtering_pram *) ugeth->p_rx_glbl_pram->
            addressfiltering;
 
        /* Ethernet frames are defined in Little Endian mode,    */
        /* therefore to insert the address we reverse the bytes. */
-       out_be16(&p_82xx_addr_filt->paddr[paddr_num].h,
-                (u16) (((u16) (((u16) ((*p_enet_addr)[5])) << 8)) |
-                       (u16) (*p_enet_addr)[4]));
-       out_be16(&p_82xx_addr_filt->paddr[paddr_num].m,
-                (u16) (((u16) (((u16) ((*p_enet_addr)[3])) << 8)) |
-                       (u16) (*p_enet_addr)[2]));
-       out_be16(&p_82xx_addr_filt->paddr[paddr_num].l,
-                (u16) (((u16) (((u16) ((*p_enet_addr)[1])) << 8)) |
-                       (u16) (*p_enet_addr)[0]));
-
+       set_mac_addr(&p_82xx_addr_filt->paddr[paddr_num].h, p_enet_addr);
        return 0;
 }
 #endif /* CONFIG_UGETH_FILTERING */
 
-static int hw_clear_addr_in_paddr(ucc_geth_private_t *ugeth, u8 paddr_num)
+static int hw_clear_addr_in_paddr(struct ucc_geth_private *ugeth, u8 paddr_num)
 {
-       ucc_geth_82xx_address_filtering_pram_t *p_82xx_addr_filt;
+       struct ucc_geth_82xx_address_filtering_pram *p_82xx_addr_filt;
 
        if (!(paddr_num < NUM_OF_PADDRS)) {
                ugeth_warn("%s: Illagel paddr_num.", __FUNCTION__);
@@ -518,7 +511,7 @@ static int hw_clear_addr_in_paddr(ucc_geth_private_t *ugeth, u8 paddr_num)
        }
 
        p_82xx_addr_filt =
-           (ucc_geth_82xx_address_filtering_pram_t *) ugeth->p_rx_glbl_pram->
+           (struct ucc_geth_82xx_address_filtering_pram *) ugeth->p_rx_glbl_pram->
            addressfiltering;
 
        /* Writing address ff.ff.ff.ff.ff.ff disables address
@@ -530,14 +523,14 @@ static int hw_clear_addr_in_paddr(ucc_geth_private_t *ugeth, u8 paddr_num)
        return 0;
 }
 
-static void hw_add_addr_in_hash(ucc_geth_private_t *ugeth,
-                               enet_addr_t *p_enet_addr)
+static void hw_add_addr_in_hash(struct ucc_geth_private *ugeth,
+                                u8 *p_enet_addr)
 {
-       ucc_geth_82xx_address_filtering_pram_t *p_82xx_addr_filt;
+       struct ucc_geth_82xx_address_filtering_pram *p_82xx_addr_filt;
        u32 cecr_subblock;
 
        p_82xx_addr_filt =
-           (ucc_geth_82xx_address_filtering_pram_t *) ugeth->p_rx_glbl_pram->
+           (struct ucc_geth_82xx_address_filtering_pram *) ugeth->p_rx_glbl_pram->
            addressfiltering;
 
        cecr_subblock =
@@ -546,25 +539,18 @@ static void hw_add_addr_in_hash(ucc_geth_private_t *ugeth,
        /* Ethernet frames are defined in Little Endian mode,
        therefor to insert */
        /* the address to the hash (Big Endian mode), we reverse the bytes.*/
-       out_be16(&p_82xx_addr_filt->taddr.h,
-                (u16) (((u16) (((u16) ((*p_enet_addr)[5])) << 8)) |
-                       (u16) (*p_enet_addr)[4]));
-       out_be16(&p_82xx_addr_filt->taddr.m,
-                (u16) (((u16) (((u16) ((*p_enet_addr)[3])) << 8)) |
-                       (u16) (*p_enet_addr)[2]));
-       out_be16(&p_82xx_addr_filt->taddr.l,
-                (u16) (((u16) (((u16) ((*p_enet_addr)[1])) << 8)) |
-                       (u16) (*p_enet_addr)[0]));
+
+       set_mac_addr(&p_82xx_addr_filt->taddr.h, p_enet_addr);
 
        qe_issue_cmd(QE_SET_GROUP_ADDRESS, cecr_subblock,
-                    (u8) QE_CR_PROTOCOL_ETHERNET, 0);
+                    QE_CR_PROTOCOL_ETHERNET, 0);
 }
 
 #ifdef CONFIG_UGETH_MAGIC_PACKET
-static void magic_packet_detection_enable(ucc_geth_private_t *ugeth)
+static void magic_packet_detection_enable(struct ucc_geth_private *ugeth)
 {
-       ucc_fast_private_t *uccf;
-       ucc_geth_t *ug_regs;
+       struct ucc_fast_private *uccf;
+       struct ucc_geth *ug_regs;
        u32 maccfg2, uccm;
 
        uccf = ugeth->uccf;
@@ -581,10 +567,10 @@ static void magic_packet_detection_enable(ucc_geth_private_t *ugeth)
        out_be32(&ug_regs->maccfg2, maccfg2);
 }
 
-static void magic_packet_detection_disable(ucc_geth_private_t *ugeth)
+static void magic_packet_detection_disable(struct ucc_geth_private *ugeth)
 {
-       ucc_fast_private_t *uccf;
-       ucc_geth_t *ug_regs;
+       struct ucc_fast_private *uccf;
+       struct ucc_geth *ug_regs;
        u32 maccfg2, uccm;
 
        uccf = ugeth->uccf;
@@ -602,26 +588,26 @@ static void magic_packet_detection_disable(ucc_geth_private_t *ugeth)
 }
 #endif /* MAGIC_PACKET */
 
-static inline int compare_addr(enet_addr_t *addr1, enet_addr_t *addr2)
+static inline int compare_addr(u8 **addr1, u8 **addr2)
 {
        return memcmp(addr1, addr2, ENET_NUM_OCTETS_PER_ADDRESS);
 }
 
 #ifdef DEBUG
-static void get_statistics(ucc_geth_private_t *ugeth,
-                          ucc_geth_tx_firmware_statistics_t *
+static void get_statistics(struct ucc_geth_private *ugeth,
+                          struct ucc_geth_tx_firmware_statistics *
                           tx_firmware_statistics,
-                          ucc_geth_rx_firmware_statistics_t *
+                          struct ucc_geth_rx_firmware_statistics *
                           rx_firmware_statistics,
-                          ucc_geth_hardware_statistics_t *hardware_statistics)
+                          struct ucc_geth_hardware_statistics *hardware_statistics)
 {
-       ucc_fast_t *uf_regs;
-       ucc_geth_t *ug_regs;
-       ucc_geth_tx_firmware_statistics_pram_t *p_tx_fw_statistics_pram;
-       ucc_geth_rx_firmware_statistics_pram_t *p_rx_fw_statistics_pram;
+       struct ucc_fast *uf_regs;
+       struct ucc_geth *ug_regs;
+       struct ucc_geth_tx_firmware_statistics_pram *p_tx_fw_statistics_pram;
+       struct ucc_geth_rx_firmware_statistics_pram *p_rx_fw_statistics_pram;
 
        ug_regs = ugeth->ug_regs;
-       uf_regs = (ucc_fast_t *) ug_regs;
+       uf_regs = (struct ucc_fast *) ug_regs;
        p_tx_fw_statistics_pram = ugeth->p_tx_fw_statistics_pram;
        p_rx_fw_statistics_pram = ugeth->p_rx_fw_statistics_pram;
 
@@ -727,7 +713,7 @@ static void get_statistics(ucc_geth_private_t *ugeth,
        }
 }
 
-static void dump_bds(ucc_geth_private_t *ugeth)
+static void dump_bds(struct ucc_geth_private *ugeth)
 {
        int i;
        int length;
@@ -736,7 +722,7 @@ static void dump_bds(ucc_geth_private_t *ugeth)
                if (ugeth->p_tx_bd_ring[i]) {
                        length =
                            (ugeth->ug_info->bdRingLenTx[i] *
-                            UCC_GETH_SIZE_OF_BD);
+                            sizeof(struct qe_bd));
                        ugeth_info("TX BDs[%d]", i);
                        mem_disp(ugeth->p_tx_bd_ring[i], length);
                }
@@ -745,14 +731,14 @@ static void dump_bds(ucc_geth_private_t *ugeth)
                if (ugeth->p_rx_bd_ring[i]) {
                        length =
                            (ugeth->ug_info->bdRingLenRx[i] *
-                            UCC_GETH_SIZE_OF_BD);
+                            sizeof(struct qe_bd));
                        ugeth_info("RX BDs[%d]", i);
                        mem_disp(ugeth->p_rx_bd_ring[i], length);
                }
        }
 }
 
-static void dump_regs(ucc_geth_private_t *ugeth)
+static void dump_regs(struct ucc_geth_private *ugeth)
 {
        int i;
 
@@ -893,7 +879,7 @@ static void dump_regs(ucc_geth_private_t *ugeth)
                        ugeth_info("Base address: 0x%08x",
                                   (u32) & ugeth->p_thread_data_tx[i]);
                        mem_disp((u8 *) & ugeth->p_thread_data_tx[i],
-                                sizeof(ucc_geth_thread_data_tx_t));
+                                sizeof(struct ucc_geth_thread_data_tx));
                }
        }
        if (ugeth->p_thread_data_rx) {
@@ -927,7 +913,7 @@ static void dump_regs(ucc_geth_private_t *ugeth)
                        ugeth_info("Base address: 0x%08x",
                                   (u32) & ugeth->p_thread_data_rx[i]);
                        mem_disp((u8 *) & ugeth->p_thread_data_rx[i],
-                                sizeof(ucc_geth_thread_data_rx_t));
+                                sizeof(struct ucc_geth_thread_data_rx));
                }
        }
        if (ugeth->p_exf_glbl_param) {
@@ -1105,7 +1091,7 @@ static void dump_regs(ucc_geth_private_t *ugeth)
                        ugeth_info("Base address: 0x%08x",
                                   (u32) & ugeth->p_send_q_mem_reg->sqqd[i]);
                        mem_disp((u8 *) & ugeth->p_send_q_mem_reg->sqqd[i],
-                                sizeof(ucc_geth_send_queue_qd_t));
+                                sizeof(struct ucc_geth_send_queue_qd));
                }
        }
        if (ugeth->p_scheduler) {
@@ -1187,7 +1173,7 @@ static void dump_regs(ucc_geth_private_t *ugeth)
                                 qe_muram_addr(in_be32
                                               (&ugeth->p_rx_bd_qs_tbl[i].
                                                bdbaseptr)),
-                                sizeof(ucc_geth_rx_prefetched_bds_t));
+                                sizeof(struct ucc_geth_rx_prefetched_bds));
                }
        }
        if (ugeth->p_init_enet_param_shadow) {
@@ -1198,7 +1184,7 @@ static void dump_regs(ucc_geth_private_t *ugeth)
                mem_disp((u8 *) ugeth->p_init_enet_param_shadow,
                         sizeof(*ugeth->p_init_enet_param_shadow));
 
-               size = sizeof(ucc_geth_thread_rx_pram_t);
+               size = sizeof(struct ucc_geth_thread_rx_pram);
                if (ugeth->ug_info->rxExtendedFiltering) {
                        size +=
                            THREAD_RX_PRAM_ADDITIONAL_FOR_EXTENDED_FILTERING;
@@ -1216,7 +1202,7 @@ static void dump_regs(ucc_geth_private_t *ugeth)
                                       &(ugeth->p_init_enet_param_shadow->
                                         txthread[0]),
                                       ENET_INIT_PARAM_MAX_ENTRIES_TX,
-                                      sizeof(ucc_geth_thread_tx_pram_t),
+                                      sizeof(struct ucc_geth_thread_tx_pram),
                                       ugeth->ug_info->riscTx, 0);
                dump_init_enet_entries(ugeth,
                                       &(ugeth->p_init_enet_param_shadow->
@@ -1578,12 +1564,12 @@ static int init_min_frame_len(u16 min_frame_length,
        return 0;
 }
 
-static int adjust_enet_interface(ucc_geth_private_t *ugeth)
+static int adjust_enet_interface(struct ucc_geth_private *ugeth)
 {
-       ucc_geth_info_t *ug_info;
-       ucc_geth_t *ug_regs;
-       ucc_fast_t *uf_regs;
-       enet_speed_e speed;
+       struct ucc_geth_info *ug_info;
+       struct ucc_geth *ug_regs;
+       struct ucc_fast *uf_regs;
+       enum enet_speed speed;
        int ret_val, rpm = 0, tbi = 0, r10m = 0, rmm =
            0, limited_to_full_duplex = 0;
        u32 upsmr, maccfg2, utbipar, tbiBaseAddress;
@@ -1691,8 +1677,8 @@ static int adjust_enet_interface(ucc_geth_private_t *ugeth)
  */
 static void adjust_link(struct net_device *dev)
 {
-       ucc_geth_private_t *ugeth = netdev_priv(dev);
-       ucc_geth_t *ug_regs;
+       struct ucc_geth_private *ugeth = netdev_priv(dev);
+       struct ucc_geth *ug_regs;
        u32 tempval;
        struct ugeth_mii_info *mii_info = ugeth->mii_info;
 
@@ -1722,7 +1708,7 @@ static void adjust_link(struct net_device *dev)
                if (mii_info->speed != ugeth->oldspeed) {
                        switch (mii_info->speed) {
                        case 1000:
-#ifdef CONFIG_MPC836x
+#ifdef CONFIG_PPC_MPC836x
 /* FIXME: This code is for 100Mbs BUG fixing,
 remove this when it is fixed!!! */
                                if (ugeth->ug_info->enet_interface ==
@@ -1768,7 +1754,7 @@ remove this when it is fixed!!! */
                                break;
                        case 100:
                        case 10:
-#ifdef CONFIG_MPC836x
+#ifdef CONFIG_PPC_MPC836x
 /* FIXME: This code is for 100Mbs BUG fixing,
 remove this lines when it will be fixed!!! */
                                ugeth->ug_info->enet_interface = ENET_100_RGMII;
@@ -1827,9 +1813,9 @@ remove this lines when it will be fixed!!! */
  */
 static int init_phy(struct net_device *dev)
 {
-       ucc_geth_private_t *ugeth = netdev_priv(dev);
+       struct ucc_geth_private *ugeth = netdev_priv(dev);
        struct phy_info *curphy;
-       ucc_mii_mng_t *mii_regs;
+       struct ucc_mii_mng *mii_regs;
        struct ugeth_mii_info *mii_info;
        int err;
 
@@ -1914,17 +1900,17 @@ static int init_phy(struct net_device *dev)
 }
 
 #ifdef CONFIG_UGETH_TX_ON_DEMOND
-static int ugeth_transmit_on_demand(ucc_geth_private_t *ugeth)
+static int ugeth_transmit_on_demand(struct ucc_geth_private *ugeth)
 {
-       ucc_fast_transmit_on_demand(ugeth->uccf);
+       struct ucc_fastransmit_on_demand(ugeth->uccf);
 
        return 0;
 }
 #endif
 
-static int ugeth_graceful_stop_tx(ucc_geth_private_t *ugeth)
+static int ugeth_graceful_stop_tx(struct ucc_geth_private *ugeth)
 {
-       ucc_fast_private_t *uccf;
+       struct ucc_fast_private *uccf;
        u32 cecr_subblock;
        u32 temp;
 
@@ -1940,7 +1926,7 @@ static int ugeth_graceful_stop_tx(ucc_geth_private_t *ugeth)
        cecr_subblock =
            ucc_fast_get_qe_cr_subblock(ugeth->ug_info->uf_info.ucc_num);
        qe_issue_cmd(QE_GRACEFUL_STOP_TX, cecr_subblock,
-                    (u8) QE_CR_PROTOCOL_ETHERNET, 0);
+                    QE_CR_PROTOCOL_ETHERNET, 0);
 
        /* Wait for command to complete */
        do {
@@ -1952,9 +1938,9 @@ static int ugeth_graceful_stop_tx(ucc_geth_private_t *ugeth)
        return 0;
 }
 
-static int ugeth_graceful_stop_rx(ucc_geth_private_t * ugeth)
+static int ugeth_graceful_stop_rx(struct ucc_geth_private * ugeth)
 {
-       ucc_fast_private_t *uccf;
+       struct ucc_fast_private *uccf;
        u32 cecr_subblock;
        u8 temp;
 
@@ -1973,7 +1959,7 @@ static int ugeth_graceful_stop_rx(ucc_geth_private_t * ugeth)
                    ucc_fast_get_qe_cr_subblock(ugeth->ug_info->uf_info.
                                                ucc_num);
                qe_issue_cmd(QE_GRACEFUL_STOP_RX, cecr_subblock,
-                            (u8) QE_CR_PROTOCOL_ETHERNET, 0);
+                            QE_CR_PROTOCOL_ETHERNET, 0);
 
                temp = ugeth->p_rx_glbl_pram->rxgstpack;
        } while (!(temp & GRACEFUL_STOP_ACKNOWLEDGE_RX));
@@ -1983,41 +1969,40 @@ static int ugeth_graceful_stop_rx(ucc_geth_private_t * ugeth)
        return 0;
 }
 
-static int ugeth_restart_tx(ucc_geth_private_t *ugeth)
+static int ugeth_restart_tx(struct ucc_geth_private *ugeth)
 {
-       ucc_fast_private_t *uccf;
+       struct ucc_fast_private *uccf;
        u32 cecr_subblock;
 
        uccf = ugeth->uccf;
 
        cecr_subblock =
            ucc_fast_get_qe_cr_subblock(ugeth->ug_info->uf_info.ucc_num);
-       qe_issue_cmd(QE_RESTART_TX, cecr_subblock, (u8) QE_CR_PROTOCOL_ETHERNET,
-                    0);
+       qe_issue_cmd(QE_RESTART_TX, cecr_subblock, QE_CR_PROTOCOL_ETHERNET, 0);
        uccf->stopped_tx = 0;
 
        return 0;
 }
 
-static int ugeth_restart_rx(ucc_geth_private_t *ugeth)
+static int ugeth_restart_rx(struct ucc_geth_private *ugeth)
 {
-       ucc_fast_private_t *uccf;
+       struct ucc_fast_private *uccf;
        u32 cecr_subblock;
 
        uccf = ugeth->uccf;
 
        cecr_subblock =
            ucc_fast_get_qe_cr_subblock(ugeth->ug_info->uf_info.ucc_num);
-       qe_issue_cmd(QE_RESTART_RX, cecr_subblock, (u8) QE_CR_PROTOCOL_ETHERNET,
+       qe_issue_cmd(QE_RESTART_RX, cecr_subblock, QE_CR_PROTOCOL_ETHERNET,
                     0);
        uccf->stopped_rx = 0;
 
        return 0;
 }
 
-static int ugeth_enable(ucc_geth_private_t *ugeth, comm_dir_e mode)
+static int ugeth_enable(struct ucc_geth_private *ugeth, enum comm_dir mode)
 {
-       ucc_fast_private_t *uccf;
+       struct ucc_fast_private *uccf;
        int enabled_tx, enabled_rx;
 
        uccf = ugeth->uccf;
@@ -2044,9 +2029,9 @@ static int ugeth_enable(ucc_geth_private_t *ugeth, comm_dir_e mode)
 
 }
 
-static int ugeth_disable(ucc_geth_private_t * ugeth, comm_dir_e mode)
+static int ugeth_disable(struct ucc_geth_private * ugeth, enum comm_dir mode)
 {
-       ucc_fast_private_t *uccf;
+       struct ucc_fast_private *uccf;
 
        uccf = ugeth->uccf;
 
@@ -2069,7 +2054,7 @@ static int ugeth_disable(ucc_geth_private_t * ugeth, comm_dir_e mode)
        return 0;
 }
 
-static void ugeth_dump_regs(ucc_geth_private_t *ugeth)
+static void ugeth_dump_regs(struct ucc_geth_private *ugeth)
 {
 #ifdef DEBUG
        ucc_fast_dump_regs(ugeth->uccf);
@@ -2079,9 +2064,9 @@ static void ugeth_dump_regs(ucc_geth_private_t *ugeth)
 }
 
 #ifdef CONFIG_UGETH_FILTERING
-static int ugeth_ext_filtering_serialize_tad(ucc_geth_tad_params_t *
+static int ugeth_ext_filtering_serialize_tad(struct ucc_geth_tad_params *
                                             p_UccGethTadParams,
-                                            qe_fltr_tad_t *qe_fltr_tad)
+                                            struct qe_fltr_tad *qe_fltr_tad)
 {
        u16 temp;
 
@@ -2119,11 +2104,11 @@ static int ugeth_ext_filtering_serialize_tad(ucc_geth_tad_params_t *
        return 0;
 }
 
-static enet_addr_container_t
-    *ugeth_82xx_filtering_get_match_addr_in_hash(ucc_geth_private_t *ugeth,
-                                                enet_addr_t *p_enet_addr)
+static struct enet_addr_container_t
+    *ugeth_82xx_filtering_get_match_addr_in_hash(struct ucc_geth_private *ugeth,
+                                                struct enet_addr *p_enet_addr)
 {
-       enet_addr_container_t *enet_addr_cont;
+       struct enet_addr_container *enet_addr_cont;
        struct list_head *p_lh;
        u16 i, num;
        int32_t j;
@@ -2144,7 +2129,7 @@ static enet_addr_container_t
 
        for (i = 0; i < num; i++) {
                enet_addr_cont =
-                   (enet_addr_container_t *)
+                   (struct enet_addr_container *)
                    ENET_ADDR_CONT_ENTRY(dequeue(p_lh));
                for (j = ENET_NUM_OCTETS_PER_ADDRESS - 1; j >= 0; j--) {
                        if ((*p_enet_addr)[j] != (enet_addr_cont->address)[j])
@@ -2157,11 +2142,11 @@ static enet_addr_container_t
        return NULL;
 }
 
-static int ugeth_82xx_filtering_add_addr_in_hash(ucc_geth_private_t *ugeth,
-                                                enet_addr_t *p_enet_addr)
+static int ugeth_82xx_filtering_add_addr_in_hash(struct ucc_geth_private *ugeth,
+                                                struct enet_addr *p_enet_addr)
 {
-       ucc_geth_enet_address_recognition_location_e location;
-       enet_addr_container_t *enet_addr_cont;
+       enum ucc_geth_enet_address_recognition_location location;
+       struct enet_addr_container *enet_addr_cont;
        struct list_head *p_lh;
        u8 i;
        u32 limit;
@@ -2196,18 +2181,17 @@ static int ugeth_82xx_filtering_add_addr_in_hash(ucc_geth_private_t *ugeth,
        enqueue(p_lh, &enet_addr_cont->node);   /* Put it back */
        ++(*p_counter);
 
-       hw_add_addr_in_hash(ugeth, &(enet_addr_cont->address));
-
+       hw_add_addr_in_hash(ugeth, enet_addr_cont->address);
        return 0;
 }
 
-static int ugeth_82xx_filtering_clear_addr_in_hash(ucc_geth_private_t *ugeth,
-                                                  enet_addr_t *p_enet_addr)
+static int ugeth_82xx_filtering_clear_addr_in_hash(struct ucc_geth_private *ugeth,
+                                                  struct enet_addr *p_enet_addr)
 {
-       ucc_geth_82xx_address_filtering_pram_t *p_82xx_addr_filt;
-       enet_addr_container_t *enet_addr_cont;
-       ucc_fast_private_t *uccf;
-       comm_dir_e comm_dir;
+       struct ucc_geth_82xx_address_filtering_pram *p_82xx_addr_filt;
+       struct enet_addr_container *enet_addr_cont;
+       struct ucc_fast_private *uccf;
+       enum comm_dir comm_dir;
        u16 i, num;
        struct list_head *p_lh;
        u32 *addr_h, *addr_l;
@@ -2216,7 +2200,7 @@ static int ugeth_82xx_filtering_clear_addr_in_hash(ucc_geth_private_t *ugeth,
        uccf = ugeth->uccf;
 
        p_82xx_addr_filt =
-           (ucc_geth_82xx_address_filtering_pram_t *) ugeth->p_rx_glbl_pram->
+           (struct ucc_geth_82xx_address_filtering_pram *) ugeth->p_rx_glbl_pram->
            addressfiltering;
 
        if (!
@@ -2256,9 +2240,9 @@ static int ugeth_82xx_filtering_clear_addr_in_hash(ucc_geth_private_t *ugeth,
        num = --(*p_counter);
        for (i = 0; i < num; i++) {
                enet_addr_cont =
-                   (enet_addr_container_t *)
+                   (struct enet_addr_container *)
                    ENET_ADDR_CONT_ENTRY(dequeue(p_lh));
-               hw_add_addr_in_hash(ugeth, &(enet_addr_cont->address));
+               hw_add_addr_in_hash(ugeth, enet_addr_cont->address);
                enqueue(p_lh, &enet_addr_cont->node);   /* Put it back */
        }
 
@@ -2269,14 +2253,14 @@ static int ugeth_82xx_filtering_clear_addr_in_hash(ucc_geth_private_t *ugeth,
 }
 #endif /* CONFIG_UGETH_FILTERING */
 
-static int ugeth_82xx_filtering_clear_all_addr_in_hash(ucc_geth_private_t *
+static int ugeth_82xx_filtering_clear_all_addr_in_hash(struct ucc_geth_private *
                                                       ugeth,
-                                                      enet_addr_type_e
+                                                      enum enet_addr_type
                                                       enet_addr_type)
 {
-       ucc_geth_82xx_address_filtering_pram_t *p_82xx_addr_filt;
-       ucc_fast_private_t *uccf;
-       comm_dir_e comm_dir;
+       struct ucc_geth_82xx_address_filtering_pram *p_82xx_addr_filt;
+       struct ucc_fast_private *uccf;
+       enum comm_dir comm_dir;
        struct list_head *p_lh;
        u16 i, num;
        u32 *addr_h, *addr_l;
@@ -2285,7 +2269,7 @@ static int ugeth_82xx_filtering_clear_all_addr_in_hash(ucc_geth_private_t *
        uccf = ugeth->uccf;
 
        p_82xx_addr_filt =
-           (ucc_geth_82xx_address_filtering_pram_t *) ugeth->p_rx_glbl_pram->
+           (struct ucc_geth_82xx_address_filtering_pram *) ugeth->p_rx_glbl_pram->
            addressfiltering;
 
        if (enet_addr_type == ENET_ADDR_TYPE_GROUP) {
@@ -2331,8 +2315,8 @@ static int ugeth_82xx_filtering_clear_all_addr_in_hash(ucc_geth_private_t *
 }
 
 #ifdef CONFIG_UGETH_FILTERING
-static int ugeth_82xx_filtering_add_addr_in_paddr(ucc_geth_private_t *ugeth,
-                                                 enet_addr_t *p_enet_addr,
+static int ugeth_82xx_filtering_add_addr_in_paddr(struct ucc_geth_private *ugeth,
+                                                 struct enet_addr *p_enet_addr,
                                                  u8 paddr_num)
 {
        int i;
@@ -2352,14 +2336,14 @@ static int ugeth_82xx_filtering_add_addr_in_paddr(ucc_geth_private_t *ugeth,
 }
 #endif /* CONFIG_UGETH_FILTERING */
 
-static int ugeth_82xx_filtering_clear_addr_in_paddr(ucc_geth_private_t *ugeth,
+static int ugeth_82xx_filtering_clear_addr_in_paddr(struct ucc_geth_private *ugeth,
                                                    u8 paddr_num)
 {
        ugeth->indAddrRegUsed[paddr_num] = 0; /* mark this paddr as not used */
        return hw_clear_addr_in_paddr(ugeth, paddr_num);/* clear in hardware */
 }
 
-static void ucc_geth_memclean(ucc_geth_private_t *ugeth)
+static void ucc_geth_memclean(struct ucc_geth_private *ugeth)
 {
        u16 i, j;
        u8 *bd;
@@ -2433,8 +2417,8 @@ static void ucc_geth_memclean(ucc_geth_private_t *ugeth)
                for (j = 0; j < ugeth->ug_info->bdRingLenTx[i]; j++) {
                        if (ugeth->tx_skbuff[i][j]) {
                                dma_unmap_single(NULL,
-                                                BD_BUFFER_ARG(bd),
-                                                (BD_STATUS_AND_LENGTH(bd) &
+                                                ((qe_bd_t *)bd)->buf,
+                                                (in_be32((u32 *)bd) &
                                                  BD_LENGTH_MASK),
                                                 DMA_TO_DEVICE);
                                dev_kfree_skb_any(ugeth->tx_skbuff[i][j]);
@@ -2460,18 +2444,17 @@ static void ucc_geth_memclean(ucc_geth_private_t *ugeth)
                        bd = ugeth->p_rx_bd_ring[i];
                        for (j = 0; j < ugeth->ug_info->bdRingLenRx[i]; j++) {
                                if (ugeth->rx_skbuff[i][j]) {
-                                       dma_unmap_single(NULL, BD_BUFFER(bd),
-                                                ugeth->ug_info->
-                                                uf_info.
-                                                max_rx_buf_length +
-                                                UCC_GETH_RX_DATA_BUF_ALIGNMENT,
-                                                DMA_FROM_DEVICE);
-
-                                       dev_kfree_skb_any(ugeth->
-                                                         rx_skbuff[i][j]);
+                                       dma_unmap_single(NULL,
+                                               ((struct qe_bd *)bd)->buf,
+                                               ugeth->ug_info->
+                                               uf_info.max_rx_buf_length +
+                                               UCC_GETH_RX_DATA_BUF_ALIGNMENT,
+                                               DMA_FROM_DEVICE);
+                                       dev_kfree_skb_any(
+                                               ugeth->rx_skbuff[i][j]);
                                        ugeth->rx_skbuff[i][j] = NULL;
                                }
-                               bd += UCC_GETH_SIZE_OF_BD;
+                               bd += sizeof(struct qe_bd);
                        }
 
                        kfree(ugeth->rx_skbuff[i]);
@@ -2496,11 +2479,11 @@ static void ucc_geth_memclean(ucc_geth_private_t *ugeth)
 
 static void ucc_geth_set_multi(struct net_device *dev)
 {
-       ucc_geth_private_t *ugeth;
+       struct ucc_geth_private *ugeth;
        struct dev_mc_list *dmi;
-       ucc_fast_t *uf_regs;
-       ucc_geth_82xx_address_filtering_pram_t *p_82xx_addr_filt;
-       enet_addr_t tempaddr;
+       struct ucc_fast *uf_regs;
+       struct ucc_geth_82xx_address_filtering_pram *p_82xx_addr_filt;
+       u8 tempaddr[6];
        u8 *mcptr, *tdptr;
        int i, j;
 
@@ -2517,7 +2500,7 @@ static void ucc_geth_set_multi(struct net_device *dev)
                uf_regs->upsmr &= ~UPSMR_PRO;
 
                p_82xx_addr_filt =
-                   (ucc_geth_82xx_address_filtering_pram_t *) ugeth->
+                   (struct ucc_geth_82xx_address_filtering_pram *) ugeth->
                    p_rx_glbl_pram->addressfiltering;
 
                if (dev->flags & IFF_ALLMULTI) {
@@ -2546,23 +2529,22 @@ static void ucc_geth_set_multi(struct net_device *dev)
                                 * copy bytes MSB first from dmi_addr.
                                 */
                                mcptr = (u8 *) dmi->dmi_addr + 5;
-                               tdptr = (u8 *) tempaddr;
+                               tdptr = (u8 *) tempaddr;
                                for (j = 0; j < 6; j++)
                                        *tdptr++ = *mcptr--;
 
                                /* Ask CPM to run CRC and set bit in
                                 * filter mask.
                                 */
-                               hw_add_addr_in_hash(ugeth, &tempaddr);
-
+                               hw_add_addr_in_hash(ugeth, tempaddr);
                        }
                }
        }
 }
 
-static void ucc_geth_stop(ucc_geth_private_t *ugeth)
+static void ucc_geth_stop(struct ucc_geth_private *ugeth)
 {
-       ucc_geth_t *ug_regs = ugeth->ug_regs;
+       struct ucc_geth *ug_regs = ugeth->ug_regs;
        u32 tempval;
 
        ugeth_vdbg("%s: IN", __FUNCTION__);
@@ -2605,15 +2587,15 @@ static void ucc_geth_stop(ucc_geth_private_t *ugeth)
        ucc_geth_memclean(ugeth);
 }
 
-static int ucc_geth_startup(ucc_geth_private_t *ugeth)
+static int ucc_geth_startup(struct ucc_geth_private *ugeth)
 {
-       ucc_geth_82xx_address_filtering_pram_t *p_82xx_addr_filt;
-       ucc_geth_init_pram_t *p_init_enet_pram;
-       ucc_fast_private_t *uccf;
-       ucc_geth_info_t *ug_info;
-       ucc_fast_info_t *uf_info;
-       ucc_fast_t *uf_regs;
-       ucc_geth_t *ug_regs;
+       struct ucc_geth_82xx_address_filtering_pram *p_82xx_addr_filt;
+       struct ucc_geth_init_pram *p_init_enet_pram;
+       struct ucc_fast_private *uccf;
+       struct ucc_geth_info *ug_info;
+       struct ucc_fast_info *uf_info;
+       struct ucc_fast *uf_regs;
+       struct ucc_geth *ug_regs;
        int ret_val = -EINVAL;
        u32 remoder = UCC_GETH_REMODER_INIT;
        u32 init_enet_pram_offset, cecr_subblock, command, maccfg1;
@@ -2788,7 +2770,7 @@ static int ucc_geth_startup(ucc_geth_private_t *ugeth)
                UCC_GETH_VLAN_OPERATION_NON_TAGGED_NOP);
 
        uf_regs = uccf->uf_regs;
-       ug_regs = (ucc_geth_t *) (uccf->uf_regs);
+       ug_regs = (struct ucc_geth *) (uccf->uf_regs);
        ugeth->ug_regs = ug_regs;
 
        init_default_reg_vals(&uf_regs->upsmr,
@@ -2869,10 +2851,10 @@ static int ucc_geth_startup(ucc_geth_private_t *ugeth)
                /* Allocate in multiple of
                   UCC_GETH_TX_BD_RING_SIZE_MEMORY_ALIGNMENT,
                   according to spec */
-               length = ((ug_info->bdRingLenTx[j] * UCC_GETH_SIZE_OF_BD)
+               length = ((ug_info->bdRingLenTx[j] * sizeof(struct qe_bd))
                          / UCC_GETH_TX_BD_RING_SIZE_MEMORY_ALIGNMENT)
                    * UCC_GETH_TX_BD_RING_SIZE_MEMORY_ALIGNMENT;
-               if ((ug_info->bdRingLenTx[j] * UCC_GETH_SIZE_OF_BD) %
+               if ((ug_info->bdRingLenTx[j] * sizeof(struct qe_bd)) %
                    UCC_GETH_TX_BD_RING_SIZE_MEMORY_ALIGNMENT)
                        length += UCC_GETH_TX_BD_RING_SIZE_MEMORY_ALIGNMENT;
                if (uf_info->bd_mem_part == MEM_PART_SYSTEM) {
@@ -2904,13 +2886,13 @@ static int ucc_geth_startup(ucc_geth_private_t *ugeth)
                }
                /* Zero unused end of bd ring, according to spec */
                memset(ugeth->p_tx_bd_ring[j] +
-                      ug_info->bdRingLenTx[j] * UCC_GETH_SIZE_OF_BD, 0,
-                      length - ug_info->bdRingLenTx[j] * UCC_GETH_SIZE_OF_BD);
+                      ug_info->bdRingLenTx[j] * sizeof(struct qe_bd), 0,
+                      length - ug_info->bdRingLenTx[j] * sizeof(struct qe_bd));
        }
 
        /* Allocate Rx bds */
        for (j = 0; j < ug_info->numQueuesRx; j++) {
-               length = ug_info->bdRingLenRx[j] * UCC_GETH_SIZE_OF_BD;
+               length = ug_info->bdRingLenRx[j] * sizeof(struct qe_bd);
                if (uf_info->bd_mem_part == MEM_PART_SYSTEM) {
                        u32 align = 4;
                        if (UCC_GETH_RX_BD_RING_ALIGNMENT > 4)
@@ -2960,12 +2942,15 @@ static int ucc_geth_startup(ucc_geth_private_t *ugeth)
                ugeth->skb_curtx[j] = ugeth->skb_dirtytx[j] = 0;
                bd = ugeth->confBd[j] = ugeth->txBd[j] = ugeth->p_tx_bd_ring[j];
                for (i = 0; i < ug_info->bdRingLenTx[j]; i++) {
-                       BD_BUFFER_CLEAR(bd);
-                       BD_STATUS_AND_LENGTH_SET(bd, 0);
-                       bd += UCC_GETH_SIZE_OF_BD;
+                       /* clear bd buffer */
+                       out_be32(&((struct qe_bd *)bd)->buf, 0);
+                       /* set bd status and length */
+                       out_be32((u32 *)bd, 0);
+                       bd += sizeof(struct qe_bd);
                }
-               bd -= UCC_GETH_SIZE_OF_BD;
-               BD_STATUS_AND_LENGTH_SET(bd, T_W);/* for last BD set Wrap bit */
+               bd -= sizeof(struct qe_bd);
+               /* set bd status and length */
+               out_be32((u32 *)bd, T_W);       /* for last BD set Wrap bit */
        }
 
        /* Init Rx bds */
@@ -2989,12 +2974,15 @@ static int ucc_geth_startup(ucc_geth_private_t *ugeth)
                ugeth->skb_currx[j] = 0;
                bd = ugeth->rxBd[j] = ugeth->p_rx_bd_ring[j];
                for (i = 0; i < ug_info->bdRingLenRx[j]; i++) {
-                       BD_STATUS_AND_LENGTH_SET(bd, R_I);
-                       BD_BUFFER_CLEAR(bd);
-                       bd += UCC_GETH_SIZE_OF_BD;
+                       /* set bd status and length */
+                       out_be32((u32 *)bd, R_I);
+                       /* clear bd buffer */
+                       out_be32(&((struct qe_bd *)bd)->buf, 0);
+                       bd += sizeof(struct qe_bd);
                }
-               bd -= UCC_GETH_SIZE_OF_BD;
-               BD_STATUS_AND_LENGTH_SET(bd, R_W);/* for last BD set Wrap bit */
+               bd -= sizeof(struct qe_bd);
+               /* set bd status and length */
+               out_be32((u32 *)bd, R_W); /* for last BD set Wrap bit */
        }
 
        /*
@@ -3003,7 +2991,7 @@ static int ucc_geth_startup(ucc_geth_private_t *ugeth)
        /* Tx global PRAM */
        /* Allocate global tx parameter RAM page */
        ugeth->tx_glbl_pram_offset =
-           qe_muram_alloc(sizeof(ucc_geth_tx_global_pram_t),
+           qe_muram_alloc(sizeof(struct ucc_geth_tx_global_pram),
                           UCC_GETH_TX_GLOBAL_PRAM_ALIGNMENT);
        if (IS_MURAM_ERR(ugeth->tx_glbl_pram_offset)) {
                ugeth_err
@@ -3013,10 +3001,10 @@ static int ucc_geth_startup(ucc_geth_private_t *ugeth)
                return -ENOMEM;
        }
        ugeth->p_tx_glbl_pram =
-           (ucc_geth_tx_global_pram_t *) qe_muram_addr(ugeth->
+           (struct ucc_geth_tx_global_pram *) qe_muram_addr(ugeth->
                                                        tx_glbl_pram_offset);
        /* Zero out p_tx_glbl_pram */
-       memset(ugeth->p_tx_glbl_pram, 0, sizeof(ucc_geth_tx_global_pram_t));
+       memset(ugeth->p_tx_glbl_pram, 0, sizeof(struct ucc_geth_tx_global_pram));
 
        /* Fill global PRAM */
 
@@ -3024,7 +3012,7 @@ static int ucc_geth_startup(ucc_geth_private_t *ugeth)
        /* Size varies with number of Tx threads */
        ugeth->thread_dat_tx_offset =
            qe_muram_alloc(numThreadsTxNumerical *
-                          sizeof(ucc_geth_thread_data_tx_t) +
+                          sizeof(struct ucc_geth_thread_data_tx) +
                           32 * (numThreadsTxNumerical == 1),
                           UCC_GETH_THREAD_DATA_ALIGNMENT);
        if (IS_MURAM_ERR(ugeth->thread_dat_tx_offset)) {
@@ -3036,7 +3024,7 @@ static int ucc_geth_startup(ucc_geth_private_t *ugeth)
        }
 
        ugeth->p_thread_data_tx =
-           (ucc_geth_thread_data_tx_t *) qe_muram_addr(ugeth->
+           (struct ucc_geth_thread_data_tx *) qe_muram_addr(ugeth->
                                                        thread_dat_tx_offset);
        out_be32(&ugeth->p_tx_glbl_pram->tqptr, ugeth->thread_dat_tx_offset);
 
@@ -3053,7 +3041,7 @@ static int ucc_geth_startup(ucc_geth_private_t *ugeth)
        /* Size varies with number of Tx queues */
        ugeth->send_q_mem_reg_offset =
            qe_muram_alloc(ug_info->numQueuesTx *
-                          sizeof(ucc_geth_send_queue_qd_t),
+                          sizeof(struct ucc_geth_send_queue_qd),
                           UCC_GETH_SEND_QUEUE_QUEUE_DESCRIPTOR_ALIGNMENT);
        if (IS_MURAM_ERR(ugeth->send_q_mem_reg_offset)) {
                ugeth_err
@@ -3064,7 +3052,7 @@ static int ucc_geth_startup(ucc_geth_private_t *ugeth)
        }
 
        ugeth->p_send_q_mem_reg =
-           (ucc_geth_send_queue_mem_region_t *) qe_muram_addr(ugeth->
+           (struct ucc_geth_send_queue_mem_region *) qe_muram_addr(ugeth->
                        send_q_mem_reg_offset);
        out_be32(&ugeth->p_tx_glbl_pram->sqptr, ugeth->send_q_mem_reg_offset);
 
@@ -3073,7 +3061,7 @@ static int ucc_geth_startup(ucc_geth_private_t *ugeth)
        for (i = 0; i < ug_info->numQueuesTx; i++) {
                endOfRing =
                    ugeth->p_tx_bd_ring[i] + (ug_info->bdRingLenTx[i] -
-                                             1) * UCC_GETH_SIZE_OF_BD;
+                                             1) * sizeof(struct qe_bd);
                if (ugeth->ug_info->uf_info.bd_mem_part == MEM_PART_SYSTEM) {
                        out_be32(&ugeth->p_send_q_mem_reg->sqqd[i].bd_ring_base,
                                 (u32) virt_to_phys(ugeth->p_tx_bd_ring[i]));
@@ -3096,7 +3084,7 @@ static int ucc_geth_startup(ucc_geth_private_t *ugeth)
        if (ug_info->numQueuesTx > 1) {
        /* scheduler exists only if more than 1 tx queue */
                ugeth->scheduler_offset =
-                   qe_muram_alloc(sizeof(ucc_geth_scheduler_t),
+                   qe_muram_alloc(sizeof(struct ucc_geth_scheduler),
                                   UCC_GETH_SCHEDULER_ALIGNMENT);
                if (IS_MURAM_ERR(ugeth->scheduler_offset)) {
                        ugeth_err
@@ -3107,12 +3095,12 @@ static int ucc_geth_startup(ucc_geth_private_t *ugeth)
                }
 
                ugeth->p_scheduler =
-                   (ucc_geth_scheduler_t *) qe_muram_addr(ugeth->
+                   (struct ucc_geth_scheduler *) qe_muram_addr(ugeth->
                                                           scheduler_offset);
                out_be32(&ugeth->p_tx_glbl_pram->schedulerbasepointer,
                         ugeth->scheduler_offset);
                /* Zero out p_scheduler */
-               memset(ugeth->p_scheduler, 0, sizeof(ucc_geth_scheduler_t));
+               memset(ugeth->p_scheduler, 0, sizeof(struct ucc_geth_scheduler));
 
                /* Set values in scheduler */
                out_be32(&ugeth->p_scheduler->mblinterval,
@@ -3144,7 +3132,7 @@ static int ucc_geth_startup(ucc_geth_private_t *ugeth)
            statisticsMode & UCC_GETH_STATISTICS_GATHERING_MODE_FIRMWARE_TX) {
                ugeth->tx_fw_statistics_pram_offset =
                    qe_muram_alloc(sizeof
-                                  (ucc_geth_tx_firmware_statistics_pram_t),
+                                  (struct ucc_geth_tx_firmware_statistics_pram),
                                   UCC_GETH_TX_STATISTICS_ALIGNMENT);
                if (IS_MURAM_ERR(ugeth->tx_fw_statistics_pram_offset)) {
                        ugeth_err
@@ -3154,11 +3142,11 @@ static int ucc_geth_startup(ucc_geth_private_t *ugeth)
                        return -ENOMEM;
                }
                ugeth->p_tx_fw_statistics_pram =
-                   (ucc_geth_tx_firmware_statistics_pram_t *)
+                   (struct ucc_geth_tx_firmware_statistics_pram *)
                    qe_muram_addr(ugeth->tx_fw_statistics_pram_offset);
                /* Zero out p_tx_fw_statistics_pram */
                memset(ugeth->p_tx_fw_statistics_pram,
-                      0, sizeof(ucc_geth_tx_firmware_statistics_pram_t));
+                      0, sizeof(struct ucc_geth_tx_firmware_statistics_pram));
        }
 
        /* temoder */
@@ -3183,7 +3171,7 @@ static int ucc_geth_startup(ucc_geth_private_t *ugeth)
        /* Rx global PRAM */
        /* Allocate global rx parameter RAM page */
        ugeth->rx_glbl_pram_offset =
-           qe_muram_alloc(sizeof(ucc_geth_rx_global_pram_t),
+           qe_muram_alloc(sizeof(struct ucc_geth_rx_global_pram),
                           UCC_GETH_RX_GLOBAL_PRAM_ALIGNMENT);
        if (IS_MURAM_ERR(ugeth->rx_glbl_pram_offset)) {
                ugeth_err
@@ -3193,10 +3181,10 @@ static int ucc_geth_startup(ucc_geth_private_t *ugeth)
                return -ENOMEM;
        }
        ugeth->p_rx_glbl_pram =
-           (ucc_geth_rx_global_pram_t *) qe_muram_addr(ugeth->
+           (struct ucc_geth_rx_global_pram *) qe_muram_addr(ugeth->
                                                        rx_glbl_pram_offset);
        /* Zero out p_rx_glbl_pram */
-       memset(ugeth->p_rx_glbl_pram, 0, sizeof(ucc_geth_rx_global_pram_t));
+       memset(ugeth->p_rx_glbl_pram, 0, sizeof(struct ucc_geth_rx_global_pram));
 
        /* Fill global PRAM */
 
@@ -3204,7 +3192,7 @@ static int ucc_geth_startup(ucc_geth_private_t *ugeth)
        /* Size varies with number of Rx threads */
        ugeth->thread_dat_rx_offset =
            qe_muram_alloc(numThreadsRxNumerical *
-                          sizeof(ucc_geth_thread_data_rx_t),
+                          sizeof(struct ucc_geth_thread_data_rx),
                           UCC_GETH_THREAD_DATA_ALIGNMENT);
        if (IS_MURAM_ERR(ugeth->thread_dat_rx_offset)) {
                ugeth_err
@@ -3215,7 +3203,7 @@ static int ucc_geth_startup(ucc_geth_private_t *ugeth)
        }
 
        ugeth->p_thread_data_rx =
-           (ucc_geth_thread_data_rx_t *) qe_muram_addr(ugeth->
+           (struct ucc_geth_thread_data_rx *) qe_muram_addr(ugeth->
                                                        thread_dat_rx_offset);
        out_be32(&ugeth->p_rx_glbl_pram->rqptr, ugeth->thread_dat_rx_offset);
 
@@ -3227,7 +3215,7 @@ static int ucc_geth_startup(ucc_geth_private_t *ugeth)
            statisticsMode & UCC_GETH_STATISTICS_GATHERING_MODE_FIRMWARE_RX) {
                ugeth->rx_fw_statistics_pram_offset =
                    qe_muram_alloc(sizeof
-                                  (ucc_geth_rx_firmware_statistics_pram_t),
+                                  (struct ucc_geth_rx_firmware_statistics_pram),
                                   UCC_GETH_RX_STATISTICS_ALIGNMENT);
                if (IS_MURAM_ERR(ugeth->rx_fw_statistics_pram_offset)) {
                        ugeth_err
@@ -3237,11 +3225,11 @@ static int ucc_geth_startup(ucc_geth_private_t *ugeth)
                        return -ENOMEM;
                }
                ugeth->p_rx_fw_statistics_pram =
-                   (ucc_geth_rx_firmware_statistics_pram_t *)
+                   (struct ucc_geth_rx_firmware_statistics_pram *)
                    qe_muram_addr(ugeth->rx_fw_statistics_pram_offset);
                /* Zero out p_rx_fw_statistics_pram */
                memset(ugeth->p_rx_fw_statistics_pram, 0,
-                      sizeof(ucc_geth_rx_firmware_statistics_pram_t));
+                      sizeof(struct ucc_geth_rx_firmware_statistics_pram));
        }
 
        /* intCoalescingPtr */
@@ -3249,7 +3237,7 @@ static int ucc_geth_startup(ucc_geth_private_t *ugeth)
        /* Size varies with number of Rx queues */
        ugeth->rx_irq_coalescing_tbl_offset =
            qe_muram_alloc(ug_info->numQueuesRx *
-                          sizeof(ucc_geth_rx_interrupt_coalescing_entry_t),
+                          sizeof(struct ucc_geth_rx_interrupt_coalescing_entry),
                           UCC_GETH_RX_INTERRUPT_COALESCING_ALIGNMENT);
        if (IS_MURAM_ERR(ugeth->rx_irq_coalescing_tbl_offset)) {
                ugeth_err
@@ -3260,7 +3248,7 @@ static int ucc_geth_startup(ucc_geth_private_t *ugeth)
        }
 
        ugeth->p_rx_irq_coalescing_tbl =
-           (ucc_geth_rx_interrupt_coalescing_table_t *)
+           (struct ucc_geth_rx_interrupt_coalescing_table *)
            qe_muram_addr(ugeth->rx_irq_coalescing_tbl_offset);
        out_be32(&ugeth->p_rx_glbl_pram->intcoalescingptr,
                 ugeth->rx_irq_coalescing_tbl_offset);
@@ -3300,7 +3288,7 @@ static int ucc_geth_startup(ucc_geth_private_t *ugeth)
                l3qt = 0;
                for (i = 0; i < 8; i++)
                        l3qt |= (ug_info->l3qt[j + i] << (28 - 4 * i));
-               out_be32(&ugeth->p_rx_glbl_pram->l3qt[j], l3qt);
+               out_be32(&ugeth->p_rx_glbl_pram->l3qt[j/8], l3qt);
        }
 
        /* vlantype */
@@ -3316,8 +3304,8 @@ static int ucc_geth_startup(ucc_geth_private_t *ugeth)
        /* Size varies with number of Rx queues */
        ugeth->rx_bd_qs_tbl_offset =
            qe_muram_alloc(ug_info->numQueuesRx *
-                          (sizeof(ucc_geth_rx_bd_queues_entry_t) +
-                           sizeof(ucc_geth_rx_prefetched_bds_t)),
+                          (sizeof(struct ucc_geth_rx_bd_queues_entry) +
+                           sizeof(struct ucc_geth_rx_prefetched_bds)),
                           UCC_GETH_RX_BD_QUEUES_ALIGNMENT);
        if (IS_MURAM_ERR(ugeth->rx_bd_qs_tbl_offset)) {
                ugeth_err
@@ -3328,14 +3316,14 @@ static int ucc_geth_startup(ucc_geth_private_t *ugeth)
        }
 
        ugeth->p_rx_bd_qs_tbl =
-           (ucc_geth_rx_bd_queues_entry_t *) qe_muram_addr(ugeth->
+           (struct ucc_geth_rx_bd_queues_entry *) qe_muram_addr(ugeth->
                                    rx_bd_qs_tbl_offset);
        out_be32(&ugeth->p_rx_glbl_pram->rbdqptr, ugeth->rx_bd_qs_tbl_offset);
        /* Zero out p_rx_bd_qs_tbl */
        memset(ugeth->p_rx_bd_qs_tbl,
               0,
-              ug_info->numQueuesRx * (sizeof(ucc_geth_rx_bd_queues_entry_t) +
-                                      sizeof(ucc_geth_rx_prefetched_bds_t)));
+              ug_info->numQueuesRx * (sizeof(struct ucc_geth_rx_bd_queues_entry) +
+                                      sizeof(struct ucc_geth_rx_prefetched_bds)));
 
        /* Setup the table */
        /* Assume BD rings are already established */
@@ -3406,7 +3394,7 @@ static int ucc_geth_startup(ucc_geth_private_t *ugeth)
                /* Allocate memory for extended filtering Mode Global
                Parameters */
                ugeth->exf_glbl_param_offset =
-                   qe_muram_alloc(sizeof(ucc_geth_exf_global_pram_t),
+                   qe_muram_alloc(sizeof(struct ucc_geth_exf_global_pram),
                UCC_GETH_RX_EXTENDED_FILTERING_GLOBAL_PARAMETERS_ALIGNMENT);
                if (IS_MURAM_ERR(ugeth->exf_glbl_param_offset)) {
                        ugeth_err
@@ -3417,7 +3405,7 @@ static int ucc_geth_startup(ucc_geth_private_t *ugeth)
                }
 
                ugeth->p_exf_glbl_param =
-                   (ucc_geth_exf_global_pram_t *) qe_muram_addr(ugeth->
+                   (struct ucc_geth_exf_global_pram *) qe_muram_addr(ugeth->
                                 exf_glbl_param_offset);
                out_be32(&ugeth->p_rx_glbl_pram->exfGlobalParam,
                         ugeth->exf_glbl_param_offset);
@@ -3439,7 +3427,7 @@ static int ucc_geth_startup(ucc_geth_private_t *ugeth)
                        INIT_LIST_HEAD(&ugeth->ind_hash_q);
                }
                p_82xx_addr_filt =
-                   (ucc_geth_82xx_address_filtering_pram_t *) ugeth->
+                   (struct ucc_geth_82xx_address_filtering_pram *) ugeth->
                    p_rx_glbl_pram->addressfiltering;
 
                ugeth_82xx_filtering_clear_all_addr_in_hash(ugeth,
@@ -3462,7 +3450,7 @@ static int ucc_geth_startup(ucc_geth_private_t *ugeth)
         * allocated resources can be released when the channel is freed.
         */
        if (!(ugeth->p_init_enet_param_shadow =
-            (ucc_geth_init_pram_t *) kmalloc(sizeof(ucc_geth_init_pram_t),
+            (struct ucc_geth_init_pram *) kmalloc(sizeof(struct ucc_geth_init_pram),
                                              GFP_KERNEL))) {
                ugeth_err
                    ("%s: Can not allocate memory for"
@@ -3472,7 +3460,7 @@ static int ucc_geth_startup(ucc_geth_private_t *ugeth)
        }
        /* Zero out *p_init_enet_param_shadow */
        memset((char *)ugeth->p_init_enet_param_shadow,
-              0, sizeof(ucc_geth_init_pram_t));
+              0, sizeof(struct ucc_geth_init_pram));
 
        /* Fill shadow InitEnet command parameter structure */
 
@@ -3506,7 +3494,7 @@ static int ucc_geth_startup(ucc_geth_private_t *ugeth)
        }
        ugeth->p_init_enet_param_shadow->largestexternallookupkeysize =
            ug_info->largestexternallookupkeysize;
-       size = sizeof(ucc_geth_thread_rx_pram_t);
+       size = sizeof(struct ucc_geth_thread_rx_pram);
        if (ug_info->rxExtendedFiltering) {
                size += THREAD_RX_PRAM_ADDITIONAL_FOR_EXTENDED_FILTERING;
                if (ug_info->largestexternallookupkeysize ==
@@ -3537,7 +3525,7 @@ static int ucc_geth_startup(ucc_geth_private_t *ugeth)
             fill_init_enet_entries(ugeth,
                                    &(ugeth->p_init_enet_param_shadow->
                                      txthread[0]), numThreadsTxNumerical,
-                                   sizeof(ucc_geth_thread_tx_pram_t),
+                                   sizeof(struct ucc_geth_thread_tx_pram),
                                    UCC_GETH_THREAD_TX_PRAM_ALIGNMENT,
                                    ug_info->riscTx, 0)) != 0) {
                ugeth_err("%s: Can not fill p_init_enet_param_shadow.",
@@ -3557,7 +3545,7 @@ static int ucc_geth_startup(ucc_geth_private_t *ugeth)
        }
 
        /* Allocate InitEnet command parameter structure */
-       init_enet_pram_offset = qe_muram_alloc(sizeof(ucc_geth_init_pram_t), 4);
+       init_enet_pram_offset = qe_muram_alloc(sizeof(struct ucc_geth_init_pram), 4);
        if (IS_MURAM_ERR(init_enet_pram_offset)) {
                ugeth_err
                    ("%s: Can not allocate DPRAM memory for p_init_enet_pram.",
@@ -3566,7 +3554,7 @@ static int ucc_geth_startup(ucc_geth_private_t *ugeth)
                return -ENOMEM;
        }
        p_init_enet_pram =
-           (ucc_geth_init_pram_t *) qe_muram_addr(init_enet_pram_offset);
+           (struct ucc_geth_init_pram *) qe_muram_addr(init_enet_pram_offset);
 
        /* Copy shadow InitEnet command parameter structure into PRAM */
        p_init_enet_pram->resinit1 = ugeth->p_init_enet_param_shadow->resinit1;
@@ -3591,7 +3579,7 @@ static int ucc_geth_startup(ucc_geth_private_t *ugeth)
        /* Issue QE command */
        cecr_subblock =
            ucc_fast_get_qe_cr_subblock(ugeth->ug_info->uf_info.ucc_num);
-       qe_issue_cmd(command, cecr_subblock, (u8) QE_CR_PROTOCOL_ETHERNET,
+       qe_issue_cmd(command, cecr_subblock, QE_CR_PROTOCOL_ETHERNET,
                     init_enet_pram_offset);
 
        /* Free InitEnet command parameter */
@@ -3603,7 +3591,7 @@ static int ucc_geth_startup(ucc_geth_private_t *ugeth)
 /* returns a net_device_stats structure pointer */
 static struct net_device_stats *ucc_geth_get_stats(struct net_device *dev)
 {
-       ucc_geth_private_t *ugeth = netdev_priv(dev);
+       struct ucc_geth_private *ugeth = netdev_priv(dev);
 
        return &(ugeth->stats);
 }
@@ -3614,7 +3602,7 @@ static struct net_device_stats *ucc_geth_get_stats(struct net_device *dev)
  * starting over will fix the problem. */
 static void ucc_geth_timeout(struct net_device *dev)
 {
-       ucc_geth_private_t *ugeth = netdev_priv(dev);
+       struct ucc_geth_private *ugeth = netdev_priv(dev);
 
        ugeth_vdbg("%s: IN", __FUNCTION__);
 
@@ -3634,7 +3622,7 @@ static void ucc_geth_timeout(struct net_device *dev)
 /* It is pointed to by the dev->hard_start_xmit function pointer */
 static int ucc_geth_start_xmit(struct sk_buff *skb, struct net_device *dev)
 {
-       ucc_geth_private_t *ugeth = netdev_priv(dev);
+       struct ucc_geth_private *ugeth = netdev_priv(dev);
        u8 *bd;                 /* BD pointer */
        u32 bd_status;
        u8 txQ = 0;
@@ -3647,7 +3635,7 @@ static int ucc_geth_start_xmit(struct sk_buff *skb, struct net_device *dev)
 
        /* Start from the next BD that should be filled */
        bd = ugeth->txBd[txQ];
-       bd_status = BD_STATUS_AND_LENGTH(bd);
+       bd_status = in_be32((u32 *)bd);
        /* Save the skb pointer so we can free it later */
        ugeth->tx_skbuff[txQ][ugeth->skb_curtx[txQ]] = skb;
 
@@ -3657,20 +3645,21 @@ static int ucc_geth_start_xmit(struct sk_buff *skb, struct net_device *dev)
             1) & TX_RING_MOD_MASK(ugeth->ug_info->bdRingLenTx[txQ]);
 
        /* set up the buffer descriptor */
-       BD_BUFFER_SET(bd,
+       out_be32(&((struct qe_bd *)bd)->buf,
                      dma_map_single(NULL, skb->data, skb->len, DMA_TO_DEVICE));
 
-       //printk(KERN_DEBUG"skb->data is 0x%x\n",skb->data);
+       /* printk(KERN_DEBUG"skb->data is 0x%x\n",skb->data); */
 
        bd_status = (bd_status & T_W) | T_R | T_I | T_L | skb->len;
 
-       BD_STATUS_AND_LENGTH_SET(bd, bd_status);
+       /* set bd status and length */
+       out_be32((u32 *)bd, bd_status);
 
        dev->trans_start = jiffies;
 
        /* Move to next BD in the ring */
        if (!(bd_status & T_W))
-               ugeth->txBd[txQ] = bd + UCC_GETH_SIZE_OF_BD;
+               ugeth->txBd[txQ] = bd + sizeof(struct qe_bd);
        else
                ugeth->txBd[txQ] = ugeth->p_tx_bd_ring[txQ];
 
@@ -3695,7 +3684,7 @@ static int ucc_geth_start_xmit(struct sk_buff *skb, struct net_device *dev)
        return 0;
 }
 
-static int ucc_geth_rx(ucc_geth_private_t *ugeth, u8 rxQ, int rx_work_limit)
+static int ucc_geth_rx(struct ucc_geth_private *ugeth, u8 rxQ, int rx_work_limit)
 {
        struct sk_buff *skb;
        u8 *bd;
@@ -3709,11 +3698,11 @@ static int ucc_geth_rx(ucc_geth_private_t *ugeth, u8 rxQ, int rx_work_limit)
        /* collect received buffers */
        bd = ugeth->rxBd[rxQ];
 
-       bd_status = BD_STATUS_AND_LENGTH(bd);
+       bd_status = in_be32((u32 *)bd);
 
        /* while there are received buffers and BD is full (~R_E) */
        while (!((bd_status & (R_E)) || (--rx_work_limit < 0))) {
-               bdBuffer = (u8 *) BD_BUFFER(bd);
+               bdBuffer = (u8 *) in_be32(&((struct qe_bd *)bd)->buf);
                length = (u16) ((bd_status & BD_LENGTH_MASK) - 4);
                skb = ugeth->rx_skbuff[rxQ][ugeth->skb_currx[rxQ]];
 
@@ -3768,9 +3757,9 @@ static int ucc_geth_rx(ucc_geth_private_t *ugeth, u8 rxQ, int rx_work_limit)
                if (bd_status & R_W)
                        bd = ugeth->p_rx_bd_ring[rxQ];
                else
-                       bd += UCC_GETH_SIZE_OF_BD;
+                       bd += sizeof(struct qe_bd);
 
-               bd_status = BD_STATUS_AND_LENGTH(bd);
+               bd_status = in_be32((u32 *)bd);
        }
 
        ugeth->rxBd[rxQ] = bd;
@@ -3781,12 +3770,12 @@ static int ucc_geth_rx(ucc_geth_private_t *ugeth, u8 rxQ, int rx_work_limit)
 static int ucc_geth_tx(struct net_device *dev, u8 txQ)
 {
        /* Start from the next BD that should be filled */
-       ucc_geth_private_t *ugeth = netdev_priv(dev);
+       struct ucc_geth_private *ugeth = netdev_priv(dev);
        u8 *bd;                 /* BD pointer */
        u32 bd_status;
 
        bd = ugeth->confBd[txQ];
-       bd_status = BD_STATUS_AND_LENGTH(bd);
+       bd_status = in_be32((u32 *)bd);
 
        /* Normal processing. */
        while ((bd_status & T_R) == 0) {
@@ -3813,7 +3802,7 @@ static int ucc_geth_tx(struct net_device *dev, u8 txQ)
 
                /* Advance the confirmation BD pointer */
                if (!(bd_status & T_W))
-                       ugeth->confBd[txQ] += UCC_GETH_SIZE_OF_BD;
+                       ugeth->confBd[txQ] += sizeof(struct qe_bd);
                else
                        ugeth->confBd[txQ] = ugeth->p_tx_bd_ring[txQ];
        }
@@ -3823,7 +3812,7 @@ static int ucc_geth_tx(struct net_device *dev, u8 txQ)
 #ifdef CONFIG_UGETH_NAPI
 static int ucc_geth_poll(struct net_device *dev, int *budget)
 {
-       ucc_geth_private_t *ugeth = netdev_priv(dev);
+       struct ucc_geth_private *ugeth = netdev_priv(dev);
        int howmany;
        int rx_work_limit = *budget;
        u8 rxQ = 0;
@@ -3847,9 +3836,9 @@ static int ucc_geth_poll(struct net_device *dev, int *budget)
 static irqreturn_t ucc_geth_irq_handler(int irq, void *info)
 {
        struct net_device *dev = (struct net_device *)info;
-       ucc_geth_private_t *ugeth = netdev_priv(dev);
-       ucc_fast_private_t *uccf;
-       ucc_geth_info_t *ug_info;
+       struct ucc_geth_private *ugeth = netdev_priv(dev);
+       struct ucc_fast_private *uccf;
+       struct ucc_geth_info *ug_info;
        register u32 ucce = 0;
        register u32 bit_mask = UCCE_RXBF_SINGLE_MASK;
        register u32 tx_mask = UCCE_TXBF_SINGLE_MASK;
@@ -3912,7 +3901,7 @@ static irqreturn_t ucc_geth_irq_handler(int irq, void *info)
 static irqreturn_t phy_interrupt(int irq, void *dev_id)
 {
        struct net_device *dev = (struct net_device *)dev_id;
-       ucc_geth_private_t *ugeth = netdev_priv(dev);
+       struct ucc_geth_private *ugeth = netdev_priv(dev);
 
        ugeth_vdbg("%s: IN", __FUNCTION__);
 
@@ -3932,8 +3921,8 @@ static irqreturn_t phy_interrupt(int irq, void *dev_id)
 static void ugeth_phy_change(void *data)
 {
        struct net_device *dev = (struct net_device *)data;
-       ucc_geth_private_t *ugeth = netdev_priv(dev);
-       ucc_geth_t *ug_regs;
+       struct ucc_geth_private *ugeth = netdev_priv(dev);
+       struct ucc_geth *ug_regs;
        int result = 0;
 
        ugeth_vdbg("%s: IN", __FUNCTION__);
@@ -3963,7 +3952,7 @@ static void ugeth_phy_change(void *data)
 static void ugeth_phy_timer(unsigned long data)
 {
        struct net_device *dev = (struct net_device *)data;
-       ucc_geth_private_t *ugeth = netdev_priv(dev);
+       struct ucc_geth_private *ugeth = netdev_priv(dev);
 
        schedule_work(&ugeth->tq);
 
@@ -3979,7 +3968,7 @@ static void ugeth_phy_timer(unsigned long data)
 static void ugeth_phy_startup_timer(unsigned long data)
 {
        struct ugeth_mii_info *mii_info = (struct ugeth_mii_info *)data;
-       ucc_geth_private_t *ugeth = netdev_priv(mii_info->dev);
+       struct ucc_geth_private *ugeth = netdev_priv(mii_info->dev);
        static int secondary = UGETH_AN_TIMEOUT;
        int result;
 
@@ -4034,7 +4023,7 @@ static void ugeth_phy_startup_timer(unsigned long data)
 /* Returns 0 for success. */
 static int ucc_geth_open(struct net_device *dev)
 {
-       ucc_geth_private_t *ugeth = netdev_priv(dev);
+       struct ucc_geth_private *ugeth = netdev_priv(dev);
        int err;
 
        ugeth_vdbg("%s: IN", __FUNCTION__);
@@ -4111,7 +4100,7 @@ static int ucc_geth_open(struct net_device *dev)
 /* Stops the kernel queue, and halts the controller */
 static int ucc_geth_close(struct net_device *dev)
 {
-       ucc_geth_private_t *ugeth = netdev_priv(dev);
+       struct ucc_geth_private *ugeth = netdev_priv(dev);
 
        ugeth_vdbg("%s: IN", __FUNCTION__);
 
@@ -4130,30 +4119,53 @@ static int ucc_geth_close(struct net_device *dev)
 
 const struct ethtool_ops ucc_geth_ethtool_ops = { };
 
-static int ucc_geth_probe(struct device *device)
+static int ucc_geth_probe(struct of_device* ofdev, const struct of_device_id *match)
 {
-       struct platform_device *pdev = to_platform_device(device);
-       struct ucc_geth_platform_data *ugeth_pdata;
+       struct device *device = &ofdev->dev;
+       struct device_node *np = ofdev->node;
        struct net_device *dev = NULL;
        struct ucc_geth_private *ugeth = NULL;
        struct ucc_geth_info *ug_info;
-       int err;
+       struct resource res;
+       struct device_node *phy;
+       int err, ucc_num, phy_interface;
        static int mii_mng_configured = 0;
+       const phandle *ph;
+       const unsigned int *prop;
 
        ugeth_vdbg("%s: IN", __FUNCTION__);
 
-       ugeth_pdata = (struct ucc_geth_platform_data *)pdev->dev.platform_data;
+       prop = get_property(np, "device-id", NULL);
+       ucc_num = *prop - 1;
+       if ((ucc_num < 0) || (ucc_num > 7))
+               return -ENODEV;
+
+       ug_info = &ugeth_info[ucc_num];
+       ug_info->uf_info.ucc_num = ucc_num;
+       prop = get_property(np, "rx-clock", NULL);
+       ug_info->uf_info.rx_clock = *prop;
+       prop = get_property(np, "tx-clock", NULL);
+       ug_info->uf_info.tx_clock = *prop;
+       err = of_address_to_resource(np, 0, &res);
+       if (err)
+               return -EINVAL;
+
+       ug_info->uf_info.regs = res.start;
+       ug_info->uf_info.irq = irq_of_parse_and_map(np, 0);
+
+       ph = get_property(np, "phy-handle", NULL);
+       phy = of_find_node_by_phandle(*ph);
 
-       ug_info = &ugeth_info[pdev->id];
-       ug_info->uf_info.ucc_num = pdev->id;
-       ug_info->uf_info.rx_clock = ugeth_pdata->rx_clock;
-       ug_info->uf_info.tx_clock = ugeth_pdata->tx_clock;
-       ug_info->uf_info.regs = ugeth_pdata->phy_reg_addr;
-       ug_info->uf_info.irq = platform_get_irq(pdev, 0);
-       ug_info->phy_address = ugeth_pdata->phy_id;
-       ug_info->enet_interface = ugeth_pdata->phy_interface;
-       ug_info->board_flags = ugeth_pdata->board_flags;
-       ug_info->phy_interrupt = ugeth_pdata->phy_interrupt;
+       if (phy == NULL)
+               return -ENODEV;
+
+       prop = get_property(phy, "reg", NULL);
+       ug_info->phy_address = *prop;
+       prop = get_property(phy, "interface", NULL);
+       ug_info->enet_interface = *prop;
+       ug_info->phy_interrupt = irq_of_parse_and_map(phy, 0);
+       ug_info->board_flags = (ug_info->phy_interrupt == NO_IRQ)?
+                       0:FSL_UGETH_BRD_HAS_PHY_INTR;
 
        printk(KERN_INFO "ucc_geth: UCC%1d at 0x%8x (irq = %d) \n",
                ug_info->uf_info.ucc_num + 1, ug_info->uf_info.regs,
@@ -4161,12 +4173,44 @@ static int ucc_geth_probe(struct device *device)
 
        if (ug_info == NULL) {
                ugeth_err("%s: [%d] Missing additional data!", __FUNCTION__,
-                         pdev->id);
+                         ucc_num);
                return -ENODEV;
        }
 
+       /* FIXME: Work around for early chip rev.               */
+       /* There's a bug in initial chip rev(s) in the RGMII ac */
+       /* timing.                                              */
+       /* The following compensates by writing to the reserved */
+       /* QE Port Output Hold Registers (CPOH1?).              */
+       prop = get_property(phy, "interface", NULL);
+       phy_interface = *prop;
+       if ((phy_interface == ENET_1000_RGMII) ||
+                       (phy_interface == ENET_100_RGMII) ||
+                       (phy_interface == ENET_10_RGMII)) {
+               struct device_node *soc;
+               phys_addr_t immrbase = -1;
+               u32 *tmp_reg;
+               u32 tmp_val;
+
+               soc = of_find_node_by_type(NULL, "soc");
+               if (soc) {
+                       unsigned int size;
+                       const void *prop = get_property(soc, "reg", &size);
+                       immrbase = of_translate_address(soc, prop);
+                       of_node_put(soc);
+               };
+
+               tmp_reg = (u32 *) ioremap(immrbase + 0x14A8, 0x4);
+               tmp_val = in_be32(tmp_reg);
+               if (ucc_num == 1)
+                       out_be32(tmp_reg, tmp_val | 0x00003000);
+               else if (ucc_num == 2)
+                       out_be32(tmp_reg, tmp_val | 0x0c000000);
+               iounmap(tmp_reg);
+       }
+
        if (!mii_mng_configured) {
-               ucc_set_qe_mux_mii_mng(ug_info->uf_info.ucc_num);
+               ucc_set_qe_mux_mii_mng(ucc_num);
                mii_mng_configured = 1;
        }
 
@@ -4213,13 +4257,14 @@ static int ucc_geth_probe(struct device *device)
 
        ugeth->ug_info = ug_info;
        ugeth->dev = dev;
-       memcpy(dev->dev_addr, ugeth_pdata->mac_addr, 6);
+       memcpy(dev->dev_addr, get_property(np, "mac-address", NULL), 6);
 
        return 0;
 }
 
-static int ucc_geth_remove(struct device *device)
+static int ucc_geth_remove(struct of_device* ofdev)
 {
+       struct device *device = &ofdev->dev;
        struct net_device *dev = dev_get_drvdata(device);
        struct ucc_geth_private *ugeth = netdev_priv(dev);
 
@@ -4230,28 +4275,38 @@ static int ucc_geth_remove(struct device *device)
        return 0;
 }
 
-/* Structure for a device driver */
-static struct device_driver ucc_geth_driver = {
-       .name = DRV_NAME,
-       .bus = &platform_bus_type,
-       .probe = ucc_geth_probe,
-       .remove = ucc_geth_remove,
+static struct of_device_id ucc_geth_match[] = {
+       {
+               .type = "network",
+               .compatible = "ucc_geth",
+       },
+       {},
+};
+
+MODULE_DEVICE_TABLE(of, ucc_geth_match);
+
+static struct of_platform_driver ucc_geth_driver = {
+       .name           = DRV_NAME,
+       .match_table    = ucc_geth_match,
+       .probe          = ucc_geth_probe,
+       .remove         = ucc_geth_remove,
 };
 
 static int __init ucc_geth_init(void)
 {
        int i;
+
        printk(KERN_INFO "ucc_geth: " DRV_DESC "\n");
        for (i = 0; i < 8; i++)
                memcpy(&(ugeth_info[i]), &ugeth_primary_info,
                       sizeof(ugeth_primary_info));
 
-       return driver_register(&ucc_geth_driver);
+       return of_register_driver(&ucc_geth_driver);
 }
 
 static void __exit ucc_geth_exit(void)
 {
-       driver_unregister(&ucc_geth_driver);
+       of_unregister_driver(&ucc_geth_driver);
 }
 
 module_init(ucc_geth_init);
index 005965f5dd9beaa4fb209b50986c3716aad1aede..a66561253593c3a43ac6c6b8727f739c0918b042 100644 (file)
 #define ENET_INIT_PARAM_MAX_ENTRIES_RX  9
 #define ENET_INIT_PARAM_MAX_ENTRIES_TX  8
 
-typedef struct ucc_mii_mng {
+struct ucc_mii_mng {
        u32 miimcfg;            /* MII management configuration reg */
        u32 miimcom;            /* MII management command reg */
        u32 miimadd;            /* MII management address reg */
        u32 miimcon;            /* MII management control reg */
        u32 miimstat;           /* MII management status reg */
        u32 miimind;            /* MII management indication reg */
-} __attribute__ ((packed)) ucc_mii_mng_t;
+} __attribute__ ((packed));
 
-typedef struct ucc_geth {
-       ucc_fast_t uccf;
+struct ucc_geth {
+       struct ucc_fast uccf;
 
        u32 maccfg1;            /* mac configuration reg. 1 */
        u32 maccfg2;            /* mac configuration reg. 2 */
        u32 ipgifg;             /* interframe gap reg.  */
        u32 hafdup;             /* half-duplex reg.  */
        u8 res1[0x10];
-       ucc_mii_mng_t miimng;   /* MII management structure */
+       struct ucc_mii_mng miimng;      /* MII management structure */
        u32 ifctl;              /* interface control reg */
        u32 ifstat;             /* interface statux reg */
        u32 macstnaddr1;        /* mac station address part 1 reg */
@@ -111,7 +111,7 @@ typedef struct ucc_geth {
        u32 scar;               /* Statistics carry register */
        u32 scam;               /* Statistics caryy mask register */
        u8 res5[0x200 - 0x1c4];
-} __attribute__ ((packed)) ucc_geth_t;
+} __attribute__ ((packed));
 
 /* UCC GETH TEMODR Register */
 #define TEMODER_TX_RMON_STATISTICS_ENABLE       0x0100 /* enable Tx statistics
@@ -508,39 +508,39 @@ typedef struct ucc_geth {
 /* UCC GETH UDSR (Data Synchronization Register) */
 #define UDSR_MAGIC                              0x067E
 
-typedef struct ucc_geth_thread_data_tx {
+struct ucc_geth_thread_data_tx {
        u8 res0[104];
-} __attribute__ ((packed)) ucc_geth_thread_data_tx_t;
+} __attribute__ ((packed));
 
-typedef struct ucc_geth_thread_data_rx {
+struct ucc_geth_thread_data_rx {
        u8 res0[40];
-} __attribute__ ((packed)) ucc_geth_thread_data_rx_t;
+} __attribute__ ((packed));
 
 /* Send Queue Queue-Descriptor */
-typedef struct ucc_geth_send_queue_qd {
+struct ucc_geth_send_queue_qd {
        u32 bd_ring_base;       /* pointer to BD ring base address */
        u8 res0[0x8];
        u32 last_bd_completed_address;/* initialize to last entry in BD ring */
        u8 res1[0x30];
-} __attribute__ ((packed)) ucc_geth_send_queue_qd_t;
+} __attribute__ ((packed));
 
-typedef struct ucc_geth_send_queue_mem_region {
-       ucc_geth_send_queue_qd_t sqqd[NUM_TX_QUEUES];
-} __attribute__ ((packed)) ucc_geth_send_queue_mem_region_t;
+struct ucc_geth_send_queue_mem_region {
+       struct ucc_geth_send_queue_qd sqqd[NUM_TX_QUEUES];
+} __attribute__ ((packed));
 
-typedef struct ucc_geth_thread_tx_pram {
+struct ucc_geth_thread_tx_pram {
        u8 res0[64];
-} __attribute__ ((packed)) ucc_geth_thread_tx_pram_t;
+} __attribute__ ((packed));
 
-typedef struct ucc_geth_thread_rx_pram {
+struct ucc_geth_thread_rx_pram {
        u8 res0[128];
-} __attribute__ ((packed)) ucc_geth_thread_rx_pram_t;
+} __attribute__ ((packed));
 
 #define THREAD_RX_PRAM_ADDITIONAL_FOR_EXTENDED_FILTERING        64
 #define THREAD_RX_PRAM_ADDITIONAL_FOR_EXTENDED_FILTERING_8      64
 #define THREAD_RX_PRAM_ADDITIONAL_FOR_EXTENDED_FILTERING_16     96
 
-typedef struct ucc_geth_scheduler {
+struct ucc_geth_scheduler {
        u16 cpucount0;          /* CPU packet counter */
        u16 cpucount1;          /* CPU packet counter */
        u16 cecount0;           /* QE packet counter */
@@ -574,9 +574,9 @@ typedef struct ucc_geth_scheduler {
                                      /**< weight factor for queues   */
        u32 minw;               /* temporary variable handled by QE */
        u8 res1[0x70 - 0x64];
-} __attribute__ ((packed)) ucc_geth_scheduler_t;
+} __attribute__ ((packed));
 
-typedef struct ucc_geth_tx_firmware_statistics_pram {
+struct ucc_geth_tx_firmware_statistics_pram {
        u32 sicoltx;            /* single collision */
        u32 mulcoltx;           /* multiple collision */
        u32 latecoltxfr;        /* late collision */
@@ -596,9 +596,9 @@ typedef struct ucc_geth_tx_firmware_statistics_pram {
                                   and 1518 octets */
        u32 txpktsjumbo;        /* total packets (including bad) between 1024
                                   and MAXLength octets */
-} __attribute__ ((packed)) ucc_geth_tx_firmware_statistics_pram_t;
+} __attribute__ ((packed));
 
-typedef struct ucc_geth_rx_firmware_statistics_pram {
+struct ucc_geth_rx_firmware_statistics_pram {
        u32 frrxfcser;          /* frames with crc error */
        u32 fraligner;          /* frames with alignment error */
        u32 inrangelenrxer;     /* in range length error */
@@ -630,33 +630,33 @@ typedef struct ucc_geth_rx_firmware_statistics_pram {
                                   replaced */
        u32 insertvlan;         /* total frames that had their VLAN tag
                                   inserted */
-} __attribute__ ((packed)) ucc_geth_rx_firmware_statistics_pram_t;
+} __attribute__ ((packed));
 
-typedef struct ucc_geth_rx_interrupt_coalescing_entry {
+struct ucc_geth_rx_interrupt_coalescing_entry {
        u32 interruptcoalescingmaxvalue;        /* interrupt coalescing max
                                                   value */
        u32 interruptcoalescingcounter; /* interrupt coalescing counter,
                                           initialize to
                                           interruptcoalescingmaxvalue */
-} __attribute__ ((packed)) ucc_geth_rx_interrupt_coalescing_entry_t;
+} __attribute__ ((packed));
 
-typedef struct ucc_geth_rx_interrupt_coalescing_table {
-       ucc_geth_rx_interrupt_coalescing_entry_t coalescingentry[NUM_RX_QUEUES];
+struct ucc_geth_rx_interrupt_coalescing_table {
+       struct ucc_geth_rx_interrupt_coalescing_entry coalescingentry[NUM_RX_QUEUES];
                                       /**< interrupt coalescing entry */
-} __attribute__ ((packed)) ucc_geth_rx_interrupt_coalescing_table_t;
+} __attribute__ ((packed));
 
-typedef struct ucc_geth_rx_prefetched_bds {
-       qe_bd_t bd[NUM_BDS_IN_PREFETCHED_BDS];  /* prefetched bd */
-} __attribute__ ((packed)) ucc_geth_rx_prefetched_bds_t;
+struct ucc_geth_rx_prefetched_bds {
+       struct qe_bd bd[NUM_BDS_IN_PREFETCHED_BDS];     /* prefetched bd */
+} __attribute__ ((packed));
 
-typedef struct ucc_geth_rx_bd_queues_entry {
+struct ucc_geth_rx_bd_queues_entry {
        u32 bdbaseptr;          /* BD base pointer */
        u32 bdptr;              /* BD pointer */
        u32 externalbdbaseptr;  /* external BD base pointer */
        u32 externalbdptr;      /* external BD pointer */
-} __attribute__ ((packed)) ucc_geth_rx_bd_queues_entry_t;
+} __attribute__ ((packed));
 
-typedef struct ucc_geth_tx_global_pram {
+struct ucc_geth_tx_global_pram {
        u16 temoder;
        u8 res0[0x38 - 0x02];
        u32 sqptr;              /* a base pointer to send queue memory region */
@@ -670,15 +670,15 @@ typedef struct ucc_geth_tx_global_pram {
        u32 tqptr;              /* a base pointer to the Tx Queues Memory
                                   Region */
        u8 res2[0x80 - 0x74];
-} __attribute__ ((packed)) ucc_geth_tx_global_pram_t;
+} __attribute__ ((packed));
 
 /* structure representing Extended Filtering Global Parameters in PRAM */
-typedef struct ucc_geth_exf_global_pram {
+struct ucc_geth_exf_global_pram {
        u32 l2pcdptr;           /* individual address filter, high */
        u8 res0[0x10 - 0x04];
-} __attribute__ ((packed)) ucc_geth_exf_global_pram_t;
+} __attribute__ ((packed));
 
-typedef struct ucc_geth_rx_global_pram {
+struct ucc_geth_rx_global_pram {
        u32 remoder;            /* ethernet mode reg. */
        u32 rqptr;              /* base pointer to the Rx Queues Memory Region*/
        u32 res0[0x1];
@@ -710,12 +710,12 @@ typedef struct ucc_geth_rx_global_pram {
        u32 exfGlobalParam;     /* base address for extended filtering global
                                   parameters */
        u8 res6[0x100 - 0xC4];  /* Initialize to zero */
-} __attribute__ ((packed)) ucc_geth_rx_global_pram_t;
+} __attribute__ ((packed));
 
 #define GRACEFUL_STOP_ACKNOWLEDGE_RX            0x01
 
 /* structure representing InitEnet command */
-typedef struct ucc_geth_init_pram {
+struct ucc_geth_init_pram {
        u8 resinit1;
        u8 resinit2;
        u8 resinit3;
@@ -729,7 +729,7 @@ typedef struct ucc_geth_init_pram {
        u32 txglobal;           /* tx global */
        u32 txthread[ENET_INIT_PARAM_MAX_ENTRIES_TX];   /* tx threads */
        u8 res3[0x1];
-} __attribute__ ((packed)) ucc_geth_init_pram_t;
+} __attribute__ ((packed));
 
 #define ENET_INIT_PARAM_RGF_SHIFT               (32 - 4)
 #define ENET_INIT_PARAM_TGF_SHIFT               (32 - 8)
@@ -746,27 +746,27 @@ typedef struct ucc_geth_init_pram {
 #define ENET_INIT_PARAM_MAGIC_RES_INIT5         0x0400
 
 /* structure representing 82xx Address Filtering Enet Address in PRAM */
-typedef struct ucc_geth_82xx_enet_address {
+struct ucc_geth_82xx_enet_address {
        u8 res1[0x2];
        u16 h;                  /* address (MSB) */
        u16 m;                  /* address */
        u16 l;                  /* address (LSB) */
-} __attribute__ ((packed)) ucc_geth_82xx_enet_address_t;
+} __attribute__ ((packed));
 
 /* structure representing 82xx Address Filtering PRAM */
-typedef struct ucc_geth_82xx_address_filtering_pram {
+struct ucc_geth_82xx_address_filtering_pram {
        u32 iaddr_h;            /* individual address filter, high */
        u32 iaddr_l;            /* individual address filter, low */
        u32 gaddr_h;            /* group address filter, high */
        u32 gaddr_l;            /* group address filter, low */
-       ucc_geth_82xx_enet_address_t taddr;
-       ucc_geth_82xx_enet_address_t paddr[NUM_OF_PADDRS];
+       struct ucc_geth_82xx_enet_address taddr;
+       struct ucc_geth_82xx_enet_address paddr[NUM_OF_PADDRS];
        u8 res0[0x40 - 0x38];
-} __attribute__ ((packed)) ucc_geth_82xx_address_filtering_pram_t;
+} __attribute__ ((packed));
 
 /* GETH Tx firmware statistics structure, used when calling
    UCC_GETH_GetStatistics. */
-typedef struct ucc_geth_tx_firmware_statistics {
+struct ucc_geth_tx_firmware_statistics {
        u32 sicoltx;            /* single collision */
        u32 mulcoltx;           /* multiple collision */
        u32 latecoltxfr;        /* late collision */
@@ -786,11 +786,11 @@ typedef struct ucc_geth_tx_firmware_statistics {
                                   and 1518 octets */
        u32 txpktsjumbo;        /* total packets (including bad) between 1024
                                   and MAXLength octets */
-} __attribute__ ((packed)) ucc_geth_tx_firmware_statistics_t;
+} __attribute__ ((packed));
 
 /* GETH Rx firmware statistics structure, used when calling
    UCC_GETH_GetStatistics. */
-typedef struct ucc_geth_rx_firmware_statistics {
+struct ucc_geth_rx_firmware_statistics {
        u32 frrxfcser;          /* frames with crc error */
        u32 fraligner;          /* frames with alignment error */
        u32 inrangelenrxer;     /* in range length error */
@@ -822,11 +822,11 @@ typedef struct ucc_geth_rx_firmware_statistics {
                                   replaced */
        u32 insertvlan;         /* total frames that had their VLAN tag
                                   inserted */
-} __attribute__ ((packed)) ucc_geth_rx_firmware_statistics_t;
+} __attribute__ ((packed));
 
 /* GETH hardware statistics structure, used when calling
    UCC_GETH_GetStatistics. */
-typedef struct ucc_geth_hardware_statistics {
+struct ucc_geth_hardware_statistics {
        u32 tx64;               /* Total number of frames (including bad
                                   frames) transmitted that were exactly of the
                                   minimal length (64 for un tagged, 68 for
@@ -871,7 +871,7 @@ typedef struct ucc_geth_hardware_statistics {
        u32 rbca;               /* Total number of frames received succesfully
                                   that had destination address equal to the
                                   broadcast address */
-} __attribute__ ((packed)) ucc_geth_hardware_statistics_t;
+} __attribute__ ((packed));
 
 /* UCC GETH Tx errors returned via TxConf callback */
 #define TX_ERRORS_DEF      0x0200
@@ -1013,21 +1013,21 @@ typedef struct ucc_geth_hardware_statistics {
                                (MIIMCFG_MANAGEMENT_CLOCK_DIVIDE_BY_112)
 
 /* Ethernet speed */
-typedef enum enet_speed {
+enum enet_speed {
        ENET_SPEED_10BT,        /* 10 Base T */
        ENET_SPEED_100BT,       /* 100 Base T */
        ENET_SPEED_1000BT       /* 1000 Base T */
-} enet_speed_e;
+};
 
 /* Ethernet Address Type. */
-typedef enum enet_addr_type {
+enum enet_addr_type {
        ENET_ADDR_TYPE_INDIVIDUAL,
        ENET_ADDR_TYPE_GROUP,
        ENET_ADDR_TYPE_BROADCAST
-} enet_addr_type_e;
+};
 
 /* TBI / MII Set Register */
-typedef enum enet_tbi_mii_reg {
+enum enet_tbi_mii_reg {
        ENET_TBI_MII_CR = 0x00, /* Control (CR ) */
        ENET_TBI_MII_SR = 0x01, /* Status (SR ) */
        ENET_TBI_MII_ANA = 0x04,        /* AN advertisement (ANA ) */
@@ -1040,10 +1040,10 @@ typedef enum enet_tbi_mii_reg {
        ENET_TBI_MII_EXST = 0x0F,       /* Extended status (EXST ) */
        ENET_TBI_MII_JD = 0x10, /* Jitter diagnostics (JD ) */
        ENET_TBI_MII_TBICON = 0x11      /* TBI control (TBICON ) */
-} enet_tbi_mii_reg_e;
+};
 
 /* UCC GETH 82xx Ethernet Address Recognition Location */
-typedef enum ucc_geth_enet_address_recognition_location {
+enum ucc_geth_enet_address_recognition_location {
        UCC_GETH_ENET_ADDRESS_RECOGNITION_LOCATION_STATION_ADDRESS,/* station
                                                                      address */
        UCC_GETH_ENET_ADDRESS_RECOGNITION_LOCATION_PADDR_FIRST, /* additional
@@ -1065,10 +1065,10 @@ typedef enum ucc_geth_enet_address_recognition_location {
        UCC_GETH_ENET_ADDRESS_RECOGNITION_LOCATION_GROUP_HASH,  /* group hash */
        UCC_GETH_ENET_ADDRESS_RECOGNITION_LOCATION_INDIVIDUAL_HASH /* individual
                                                                      hash */
-} ucc_geth_enet_address_recognition_location_e;
+};
 
 /* UCC GETH vlan operation tagged */
-typedef enum ucc_geth_vlan_operation_tagged {
+enum ucc_geth_vlan_operation_tagged {
        UCC_GETH_VLAN_OPERATION_TAGGED_NOP = 0x0,       /* Tagged - nop */
        UCC_GETH_VLAN_OPERATION_TAGGED_REPLACE_VID_PORTION_OF_Q_TAG
                = 0x1,  /* Tagged - replace vid portion of q tag */
@@ -1076,18 +1076,18 @@ typedef enum ucc_geth_vlan_operation_tagged {
                = 0x2,  /* Tagged - if vid0 replace vid with default value  */
        UCC_GETH_VLAN_OPERATION_TAGGED_EXTRACT_Q_TAG_FROM_FRAME
                = 0x3   /* Tagged - extract q tag from frame */
-} ucc_geth_vlan_operation_tagged_e;
+};
 
 /* UCC GETH vlan operation non-tagged */
-typedef enum ucc_geth_vlan_operation_non_tagged {
+enum ucc_geth_vlan_operation_non_tagged {
        UCC_GETH_VLAN_OPERATION_NON_TAGGED_NOP = 0x0,   /* Non tagged - nop */
        UCC_GETH_VLAN_OPERATION_NON_TAGGED_Q_TAG_INSERT = 0x1   /* Non tagged -
                                                                   q tag insert
                                                                 */
-} ucc_geth_vlan_operation_non_tagged_e;
+};
 
 /* UCC GETH Rx Quality of Service Mode */
-typedef enum ucc_geth_qos_mode {
+enum ucc_geth_qos_mode {
        UCC_GETH_QOS_MODE_DEFAULT = 0x0,        /* default queue */
        UCC_GETH_QOS_MODE_QUEUE_NUM_FROM_L2_CRITERIA = 0x1,     /* queue
                                                                   determined
@@ -1097,11 +1097,11 @@ typedef enum ucc_geth_qos_mode {
                                                                   determined
                                                                   by L3
                                                                   criteria */
-} ucc_geth_qos_mode_e;
+};
 
 /* UCC GETH Statistics Gathering Mode - These are bit flags, 'or' them together
    for combined functionality */
-typedef enum ucc_geth_statistics_gathering_mode {
+enum ucc_geth_statistics_gathering_mode {
        UCC_GETH_STATISTICS_GATHERING_MODE_NONE = 0x00000000,   /* No
                                                                   statistics
                                                                   gathering */
@@ -1122,10 +1122,10 @@ typedef enum ucc_geth_statistics_gathering_mode {
                                                                      statistics
                                                                      gathering
                                                                    */
-} ucc_geth_statistics_gathering_mode_e;
+};
 
 /* UCC GETH Pad and CRC Mode - Note, Padding without CRC is not possible */
-typedef enum ucc_geth_maccfg2_pad_and_crc_mode {
+enum ucc_geth_maccfg2_pad_and_crc_mode {
        UCC_GETH_PAD_AND_CRC_MODE_NONE
                = MACCFG2_PAD_AND_CRC_MODE_NONE,        /* Neither Padding
                                                           short frames
@@ -1135,61 +1135,59 @@ typedef enum ucc_geth_maccfg2_pad_and_crc_mode {
                                                           CRC only */
        UCC_GETH_PAD_AND_CRC_MODE_PAD_AND_CRC =
            MACCFG2_PAD_AND_CRC_MODE_PAD_AND_CRC
-} ucc_geth_maccfg2_pad_and_crc_mode_e;
+};
 
 /* UCC GETH upsmr Flow Control Mode */
-typedef enum ucc_geth_flow_control_mode {
+enum ucc_geth_flow_control_mode {
        UPSMR_AUTOMATIC_FLOW_CONTROL_MODE_NONE = 0x00000000,    /* No automatic
                                                                   flow control
                                                                 */
        UPSMR_AUTOMATIC_FLOW_CONTROL_MODE_PAUSE_WHEN_EMERGENCY
                = 0x00004000    /* Send pause frame when RxFIFO reaches its
                                   emergency threshold */
-} ucc_geth_flow_control_mode_e;
+};
 
 /* UCC GETH number of threads */
-typedef enum ucc_geth_num_of_threads {
+enum ucc_geth_num_of_threads {
        UCC_GETH_NUM_OF_THREADS_1 = 0x1,        /* 1 */
        UCC_GETH_NUM_OF_THREADS_2 = 0x2,        /* 2 */
        UCC_GETH_NUM_OF_THREADS_4 = 0x0,        /* 4 */
        UCC_GETH_NUM_OF_THREADS_6 = 0x3,        /* 6 */
        UCC_GETH_NUM_OF_THREADS_8 = 0x4 /* 8 */
-} ucc_geth_num_of_threads_e;
+};
 
 /* UCC GETH number of station addresses */
-typedef enum ucc_geth_num_of_station_addresses {
+enum ucc_geth_num_of_station_addresses {
        UCC_GETH_NUM_OF_STATION_ADDRESSES_1,    /* 1 */
        UCC_GETH_NUM_OF_STATION_ADDRESSES_5     /* 5 */
-} ucc_geth_num_of_station_addresses_e;
-
-typedef u8 enet_addr_t[ENET_NUM_OCTETS_PER_ADDRESS];
+};
 
 /* UCC GETH 82xx Ethernet Address Container */
-typedef struct enet_addr_container {
-       enet_addr_t address;    /* ethernet address */
-       ucc_geth_enet_address_recognition_location_e location;  /* location in
+struct enet_addr_container {
+       u8 address[ENET_NUM_OCTETS_PER_ADDRESS];        /* ethernet address */
+       enum ucc_geth_enet_address_recognition_location location;       /* location in
                                                                   82xx address
                                                                   recognition
                                                                   hardware */
        struct list_head node;
-} enet_addr_container_t;
+};
 
-#define ENET_ADDR_CONT_ENTRY(ptr) list_entry(ptr, enet_addr_container_t, node)
+#define ENET_ADDR_CONT_ENTRY(ptr) list_entry(ptr, struct enet_addr_container, node)
 
 /* UCC GETH Termination Action Descriptor (TAD) structure. */
-typedef struct ucc_geth_tad_params {
+struct ucc_geth_tad_params {
        int rx_non_dynamic_extended_features_mode;
        int reject_frame;
-       ucc_geth_vlan_operation_tagged_e vtag_op;
-       ucc_geth_vlan_operation_non_tagged_e vnontag_op;
-       ucc_geth_qos_mode_e rqos;
+       enum ucc_geth_vlan_operation_tagged vtag_op;
+       enum ucc_geth_vlan_operation_non_tagged vnontag_op;
+       enum ucc_geth_qos_mode rqos;
        u8 vpri;
        u16 vid;
-} ucc_geth_tad_params_t;
+};
 
 /* GETH protocol initialization structure */
-typedef struct ucc_geth_info {
-       ucc_fast_info_t uf_info;
+struct ucc_geth_info {
+       struct ucc_fast_info uf_info;
        u8 numQueuesTx;
        u8 numQueuesRx;
        int ipCheckSumCheck;
@@ -1251,51 +1249,51 @@ typedef struct ucc_geth_info {
        u8 iphoffset[TX_IP_OFFSET_ENTRY_MAX];
        u16 bdRingLenTx[NUM_TX_QUEUES];
        u16 bdRingLenRx[NUM_RX_QUEUES];
-       enet_interface_e enet_interface;
-       ucc_geth_num_of_station_addresses_e numStationAddresses;
-        qe_fltr_largest_external_tbl_lookup_key_size_e
+       enum enet_interface enet_interface;
+       enum ucc_geth_num_of_station_addresses numStationAddresses;
+       enum qe_fltr_largest_external_tbl_lookup_key_size
            largestexternallookupkeysize;
-       ucc_geth_statistics_gathering_mode_e statisticsMode;
-       ucc_geth_vlan_operation_tagged_e vlanOperationTagged;
-       ucc_geth_vlan_operation_non_tagged_e vlanOperationNonTagged;
-       ucc_geth_qos_mode_e rxQoSMode;
-       ucc_geth_flow_control_mode_e aufc;
-       ucc_geth_maccfg2_pad_and_crc_mode_e padAndCrc;
-       ucc_geth_num_of_threads_e numThreadsTx;
-       ucc_geth_num_of_threads_e numThreadsRx;
-       qe_risc_allocation_e riscTx;
-       qe_risc_allocation_e riscRx;
-} ucc_geth_info_t;
+       enum ucc_geth_statistics_gathering_mode statisticsMode;
+       enum ucc_geth_vlan_operation_tagged vlanOperationTagged;
+       enum ucc_geth_vlan_operation_non_tagged vlanOperationNonTagged;
+       enum ucc_geth_qos_mode rxQoSMode;
+       enum ucc_geth_flow_control_mode aufc;
+       enum ucc_geth_maccfg2_pad_and_crc_mode padAndCrc;
+       enum ucc_geth_num_of_threads numThreadsTx;
+       enum ucc_geth_num_of_threads numThreadsRx;
+       enum qe_risc_allocation riscTx;
+       enum qe_risc_allocation riscRx;
+};
 
 /* structure representing UCC GETH */
-typedef struct ucc_geth_private {
-       ucc_geth_info_t *ug_info;
-       ucc_fast_private_t *uccf;
+struct ucc_geth_private {
+       struct ucc_geth_info *ug_info;
+       struct ucc_fast_private *uccf;
        struct net_device *dev;
        struct net_device_stats stats;  /* linux network statistics */
-       ucc_geth_t *ug_regs;
-       ucc_geth_init_pram_t *p_init_enet_param_shadow;
-       ucc_geth_exf_global_pram_t *p_exf_glbl_param;
+       struct ucc_geth *ug_regs;
+       struct ucc_geth_init_pram *p_init_enet_param_shadow;
+       struct ucc_geth_exf_global_pram *p_exf_glbl_param;
        u32 exf_glbl_param_offset;
-       ucc_geth_rx_global_pram_t *p_rx_glbl_pram;
+       struct ucc_geth_rx_global_pram *p_rx_glbl_pram;
        u32 rx_glbl_pram_offset;
-       ucc_geth_tx_global_pram_t *p_tx_glbl_pram;
+       struct ucc_geth_tx_global_pram *p_tx_glbl_pram;
        u32 tx_glbl_pram_offset;
-       ucc_geth_send_queue_mem_region_t *p_send_q_mem_reg;
+       struct ucc_geth_send_queue_mem_region *p_send_q_mem_reg;
        u32 send_q_mem_reg_offset;
-       ucc_geth_thread_data_tx_t *p_thread_data_tx;
+       struct ucc_geth_thread_data_tx *p_thread_data_tx;
        u32 thread_dat_tx_offset;
-       ucc_geth_thread_data_rx_t *p_thread_data_rx;
+       struct ucc_geth_thread_data_rx *p_thread_data_rx;
        u32 thread_dat_rx_offset;
-       ucc_geth_scheduler_t *p_scheduler;
+       struct ucc_geth_scheduler *p_scheduler;
        u32 scheduler_offset;
-       ucc_geth_tx_firmware_statistics_pram_t *p_tx_fw_statistics_pram;
+       struct ucc_geth_tx_firmware_statistics_pram *p_tx_fw_statistics_pram;
        u32 tx_fw_statistics_pram_offset;
-       ucc_geth_rx_firmware_statistics_pram_t *p_rx_fw_statistics_pram;
+       struct ucc_geth_rx_firmware_statistics_pram *p_rx_fw_statistics_pram;
        u32 rx_fw_statistics_pram_offset;
-       ucc_geth_rx_interrupt_coalescing_table_t *p_rx_irq_coalescing_tbl;
+       struct ucc_geth_rx_interrupt_coalescing_table *p_rx_irq_coalescing_tbl;
        u32 rx_irq_coalescing_tbl_offset;
-       ucc_geth_rx_bd_queues_entry_t *p_rx_bd_qs_tbl;
+       struct ucc_geth_rx_bd_queues_entry *p_rx_bd_qs_tbl;
        u32 rx_bd_qs_tbl_offset;
        u8 *p_tx_bd_ring[NUM_TX_QUEUES];
        u32 tx_bd_ring_offset[NUM_TX_QUEUES];
@@ -1308,7 +1306,7 @@ typedef struct ucc_geth_private {
        u16 cpucount[NUM_TX_QUEUES];
        volatile u16 *p_cpucount[NUM_TX_QUEUES];
        int indAddrRegUsed[NUM_OF_PADDRS];
-       enet_addr_t paddr[NUM_OF_PADDRS];
+       u8 paddr[NUM_OF_PADDRS][ENET_NUM_OCTETS_PER_ADDRESS];   /* ethernet address */
        u8 numGroupAddrInHash;
        u8 numIndAddrInHash;
        u8 numIndAddrInReg;
@@ -1334,6 +1332,6 @@ typedef struct ucc_geth_private {
        int oldspeed;
        int oldduplex;
        int oldlink;
-} ucc_geth_private_t;
+};
 
 #endif                         /* __UCC_GETH_H__ */
index 67260eb3188af2d771e1966af647a118b789fa1d..5360ec05eaa331b256f199714caba1df0b2c60e8 100644 (file)
@@ -42,7 +42,6 @@
 
 #include "ucc_geth.h"
 #include "ucc_geth_phy.h"
-#include <platforms/83xx/mpc8360e_pb.h>
 
 #define ugphy_printk(level, format, arg...)  \
         printk(level format "\n", ## arg)
@@ -72,16 +71,14 @@ static int genmii_read_status(struct ugeth_mii_info *mii_info);
 u16 phy_read(struct ugeth_mii_info *mii_info, u16 regnum);
 void phy_write(struct ugeth_mii_info *mii_info, u16 regnum, u16 val);
 
-static u8 *bcsr_regs = NULL;
-
 /* Write value to the PHY for this device to the register at regnum, */
 /* waiting until the write is done before it returns.  All PHY */
 /* configuration has to be done through the TSEC1 MIIM regs */
 void write_phy_reg(struct net_device *dev, int mii_id, int regnum, int value)
 {
-       ucc_geth_private_t *ugeth = netdev_priv(dev);
-       ucc_mii_mng_t *mii_regs;
-       enet_tbi_mii_reg_e mii_reg = (enet_tbi_mii_reg_e) regnum;
+       struct ucc_geth_private *ugeth = netdev_priv(dev);
+       struct ucc_mii_mng *mii_regs;
+       enum enet_tbi_mii_reg mii_reg = (enum enet_tbi_mii_reg) regnum;
        u32 tmp_reg;
 
        ugphy_vdbg("%s: IN", __FUNCTION__);
@@ -116,9 +113,9 @@ void write_phy_reg(struct net_device *dev, int mii_id, int regnum, int value)
 /* configuration has to be done through the TSEC1 MIIM regs */
 int read_phy_reg(struct net_device *dev, int mii_id, int regnum)
 {
-       ucc_geth_private_t *ugeth = netdev_priv(dev);
-       ucc_mii_mng_t *mii_regs;
-       enet_tbi_mii_reg_e mii_reg = (enet_tbi_mii_reg_e) regnum;
+       struct ucc_geth_private *ugeth = netdev_priv(dev);
+       struct ucc_mii_mng *mii_regs;
+       enum enet_tbi_mii_reg mii_reg = (enum enet_tbi_mii_reg) regnum;
        u32 tmp_reg;
        u16 value;
 
@@ -634,11 +631,6 @@ static void dm9161_close(struct ugeth_mii_info *mii_info)
 
 static int dm9161_ack_interrupt(struct ugeth_mii_info *mii_info)
 {
-/* FIXME: This lines are for BUG fixing in the mpc8325.
-Remove this from here when it's fixed */
-       if (bcsr_regs == NULL)
-               bcsr_regs = (u8 *) ioremap(BCSR_PHYS_ADDR, BCSR_SIZE);
-       bcsr_regs[14] |= 0x40;
        ugphy_vdbg("%s: IN", __FUNCTION__);
 
        /* Clear the interrupts by reading the reg */
@@ -650,12 +642,6 @@ Remove this from here when it's fixed */
 
 static int dm9161_config_intr(struct ugeth_mii_info *mii_info)
 {
-/* FIXME: This lines are for BUG fixing in the mpc8325.
-Remove this from here when it's fixed */
-       if (bcsr_regs == NULL) {
-               bcsr_regs = (u8 *) ioremap(BCSR_PHYS_ADDR, BCSR_SIZE);
-               bcsr_regs[14] &= ~0x40;
-       }
        ugphy_vdbg("%s: IN", __FUNCTION__);
 
        if (mii_info->interrupts == MII_INTERRUPT_ENABLED)
index 2f98b8f1bb0ad16c84af7c07ef5b136f9ae1d6c2..f5740783670ff540e553fd0c23cc54a3603ba8a3 100644 (file)
@@ -126,7 +126,7 @@ struct ugeth_mii_info {
        /* And management functions */
        struct phy_info *phyinfo;
 
-       ucc_mii_mng_t *mii_regs;
+       struct ucc_mii_mng *mii_regs;
 
        /* forced speed & duplex (no autoneg)
         * partner speed & duplex & pause (autoneg)
index 5823e3bca178e85e5dbd760020f6d281c08b3d56..36d1c3ff7078d28c91827e5af3d99644df09c0e0 100644 (file)
@@ -2867,7 +2867,6 @@ static int ch_config(pc300dev_t * d)
        uclong clktype = chan->conf.phys_settings.clock_type;
        ucshort encoding = chan->conf.proto_settings.encoding;
        ucshort parity = chan->conf.proto_settings.parity;   
-       int tmc, br;
        ucchar md0, md2;
     
        /* Reset the channel */
@@ -2940,8 +2939,12 @@ static int ch_config(pc300dev_t * d)
                case PC300_RSV:
                case PC300_X21:
                        if (clktype == CLOCK_INT || clktype == CLOCK_TXINT) {
+                               int tmc, br;
+
                                /* Calculate the clkrate parameters */
                                tmc = clock_rate_calc(clkrate, card->hw.clock, &br);
+                               if (tmc < 0)
+                                       return -EIO;
                                cpc_writeb(scabase + M_REG(TMCT, ch), tmc);
                                cpc_writeb(scabase + M_REG(TXS, ch),
                                           (TXS_DTRXC | TXS_IBRG | br));
@@ -3097,14 +3100,16 @@ static int cpc_attach(struct net_device *dev, unsigned short encoding,
        return 0;
 }
 
-static void cpc_opench(pc300dev_t * d)
+static int cpc_opench(pc300dev_t * d)
 {
        pc300ch_t *chan = (pc300ch_t *) d->chan;
        pc300_t *card = (pc300_t *) chan->card;
-       int ch = chan->channel;
+       int ch = chan->channel, rc;
        void __iomem *scabase = card->hw.scabase;
 
-       ch_config(d);
+       rc = ch_config(d);
+       if (rc)
+               return rc;
 
        rx_config(d);
 
@@ -3113,6 +3118,8 @@ static void cpc_opench(pc300dev_t * d)
        /* Assert RTS and DTR */
        cpc_writeb(scabase + M_REG(CTL, ch),
                   cpc_readb(scabase + M_REG(CTL, ch)) & ~(CTL_RTS | CTL_DTR));
+
+       return 0;
 }
 
 static void cpc_closech(pc300dev_t * d)
@@ -3168,9 +3175,16 @@ int cpc_open(struct net_device *dev)
        }
 
        sprintf(ifr.ifr_name, "%s", dev->name);
-       cpc_opench(d);
+       result = cpc_opench(d);
+       if (result)
+               goto err_out;
+
        netif_start_queue(dev);
        return 0;
+
+err_out:
+       hdlc_close(dev);
+       return result;
 }
 
 static int cpc_close(struct net_device *dev)
index 0a33c8a56e13b061f0d1a6b7a96ae0e4848cf149..efcdaf1c5f735fd7b5619a2c39ae221b6e0708f4 100644 (file)
@@ -2897,6 +2897,8 @@ static struct net_device *_init_airo_card( unsigned short irq, int port,
                goto err_out_map;
        }
        ai->wifidev = init_wifidev(ai, dev);
+       if (!ai->wifidev)
+               goto err_out_reg;
 
        set_bit(FLAG_REGISTERED,&ai->flags);
        airo_print_info(dev->name, "MAC enabled %x:%x:%x:%x:%x:%x",
@@ -2908,11 +2910,18 @@ static struct net_device *_init_airo_card( unsigned short irq, int port,
                for( i = 0; i < MAX_FIDS; i++ )
                        ai->fids[i] = transmit_allocate(ai,AIRO_DEF_MTU,i>=MAX_FIDS/2);
 
-       setup_proc_entry( dev, dev->priv ); /* XXX check for failure */
+       if (setup_proc_entry(dev, dev->priv) < 0)
+               goto err_out_wifi;
+
        netif_start_queue(dev);
        SET_MODULE_OWNER(dev);
        return dev;
 
+err_out_wifi:
+       unregister_netdev(ai->wifidev);
+       free_netdev(ai->wifidev);
+err_out_reg:
+       unregister_netdev(dev);
 err_out_map:
        if (test_bit(FLAG_MPI,&ai->flags) && pci) {
                pci_free_consistent(pci, PCI_SHARED_LEN, ai->shared, ai->shared_dma);
@@ -3089,7 +3098,8 @@ static int airo_thread(void *data) {
                                                set_bit(JOB_AUTOWEP, &ai->jobs);
                                                break;
                                        }
-                                       if (!kthread_should_stop()) {
+                                       if (!kthread_should_stop() &&
+                                           !freezing(current)) {
                                                unsigned long wake_at;
                                                if (!ai->expires || !ai->scan_timeout) {
                                                        wake_at = max(ai->expires,
@@ -3101,7 +3111,8 @@ static int airo_thread(void *data) {
                                                schedule_timeout(wake_at - jiffies);
                                                continue;
                                        }
-                               } else if (!kthread_should_stop()) {
+                               } else if (!kthread_should_stop() &&
+                                          !freezing(current)) {
                                        schedule();
                                        continue;
                                }
@@ -4495,91 +4506,128 @@ static int setup_proc_entry( struct net_device *dev,
        apriv->proc_entry = create_proc_entry(apriv->proc_name,
                                              S_IFDIR|airo_perm,
                                              airo_entry);
-        apriv->proc_entry->uid = proc_uid;
-        apriv->proc_entry->gid = proc_gid;
-        apriv->proc_entry->owner = THIS_MODULE;
+       if (!apriv->proc_entry)
+               goto fail;
+       apriv->proc_entry->uid = proc_uid;
+       apriv->proc_entry->gid = proc_gid;
+       apriv->proc_entry->owner = THIS_MODULE;
 
        /* Setup the StatsDelta */
        entry = create_proc_entry("StatsDelta",
                                  S_IFREG | (S_IRUGO&proc_perm),
                                  apriv->proc_entry);
-        entry->uid = proc_uid;
-        entry->gid = proc_gid;
+       if (!entry)
+               goto fail_stats_delta;
+       entry->uid = proc_uid;
+       entry->gid = proc_gid;
        entry->data = dev;
-        entry->owner = THIS_MODULE;
+       entry->owner = THIS_MODULE;
        SETPROC_OPS(entry, proc_statsdelta_ops);
 
        /* Setup the Stats */
        entry = create_proc_entry("Stats",
                                  S_IFREG | (S_IRUGO&proc_perm),
                                  apriv->proc_entry);
-        entry->uid = proc_uid;
-        entry->gid = proc_gid;
+       if (!entry)
+               goto fail_stats;
+       entry->uid = proc_uid;
+       entry->gid = proc_gid;
        entry->data = dev;
-        entry->owner = THIS_MODULE;
+       entry->owner = THIS_MODULE;
        SETPROC_OPS(entry, proc_stats_ops);
 
        /* Setup the Status */
        entry = create_proc_entry("Status",
                                  S_IFREG | (S_IRUGO&proc_perm),
                                  apriv->proc_entry);
-        entry->uid = proc_uid;
-        entry->gid = proc_gid;
+       if (!entry)
+               goto fail_status;
+       entry->uid = proc_uid;
+       entry->gid = proc_gid;
        entry->data = dev;
-        entry->owner = THIS_MODULE;
+       entry->owner = THIS_MODULE;
        SETPROC_OPS(entry, proc_status_ops);
 
        /* Setup the Config */
        entry = create_proc_entry("Config",
                                  S_IFREG | proc_perm,
                                  apriv->proc_entry);
-        entry->uid = proc_uid;
-        entry->gid = proc_gid;
+       if (!entry)
+               goto fail_config;
+       entry->uid = proc_uid;
+       entry->gid = proc_gid;
        entry->data = dev;
-        entry->owner = THIS_MODULE;
+       entry->owner = THIS_MODULE;
        SETPROC_OPS(entry, proc_config_ops);
 
        /* Setup the SSID */
        entry = create_proc_entry("SSID",
                                  S_IFREG | proc_perm,
                                  apriv->proc_entry);
-        entry->uid = proc_uid;
-        entry->gid = proc_gid;
+       if (!entry)
+               goto fail_ssid;
+       entry->uid = proc_uid;
+       entry->gid = proc_gid;
        entry->data = dev;
-        entry->owner = THIS_MODULE;
+       entry->owner = THIS_MODULE;
        SETPROC_OPS(entry, proc_SSID_ops);
 
        /* Setup the APList */
        entry = create_proc_entry("APList",
                                  S_IFREG | proc_perm,
                                  apriv->proc_entry);
-        entry->uid = proc_uid;
-        entry->gid = proc_gid;
+       if (!entry)
+               goto fail_aplist;
+       entry->uid = proc_uid;
+       entry->gid = proc_gid;
        entry->data = dev;
-        entry->owner = THIS_MODULE;
+       entry->owner = THIS_MODULE;
        SETPROC_OPS(entry, proc_APList_ops);
 
        /* Setup the BSSList */
        entry = create_proc_entry("BSSList",
                                  S_IFREG | proc_perm,
                                  apriv->proc_entry);
+       if (!entry)
+               goto fail_bsslist;
        entry->uid = proc_uid;
        entry->gid = proc_gid;
        entry->data = dev;
-        entry->owner = THIS_MODULE;
+       entry->owner = THIS_MODULE;
        SETPROC_OPS(entry, proc_BSSList_ops);
 
        /* Setup the WepKey */
        entry = create_proc_entry("WepKey",
                                  S_IFREG | proc_perm,
                                  apriv->proc_entry);
-        entry->uid = proc_uid;
-        entry->gid = proc_gid;
+       if (!entry)
+               goto fail_wepkey;
+       entry->uid = proc_uid;
+       entry->gid = proc_gid;
        entry->data = dev;
-        entry->owner = THIS_MODULE;
+       entry->owner = THIS_MODULE;
        SETPROC_OPS(entry, proc_wepkey_ops);
 
        return 0;
+
+fail_wepkey:
+       remove_proc_entry("BSSList", apriv->proc_entry);
+fail_bsslist:
+       remove_proc_entry("APList", apriv->proc_entry);
+fail_aplist:
+       remove_proc_entry("SSID", apriv->proc_entry);
+fail_ssid:
+       remove_proc_entry("Config", apriv->proc_entry);
+fail_config:
+       remove_proc_entry("Status", apriv->proc_entry);
+fail_status:
+       remove_proc_entry("Stats", apriv->proc_entry);
+fail_stats:
+       remove_proc_entry("StatsDelta", apriv->proc_entry);
+fail_stats_delta:
+       remove_proc_entry(apriv->proc_name, airo_entry);
+fail:
+       return -ENOMEM;
 }
 
 static int takedown_proc_entry( struct net_device *dev,
@@ -5924,7 +5972,6 @@ static int airo_get_essid(struct net_device *dev,
 
        /* Get the current SSID */
        memcpy(extra, status_rid.SSID, status_rid.SSIDlen);
-       extra[status_rid.SSIDlen] = '\0';
        /* If none, we may want to get the one that was set */
 
        /* Push it out ! */
index 31eed85de60f198c33db0c536592c68ec323a02a..0c07b8b7250d604b8ffd453b947020c9aec3ae46 100644 (file)
@@ -1678,11 +1678,9 @@ static int atmel_get_essid(struct net_device *dev,
        /* Get the current SSID */
        if (priv->new_SSID_size != 0) {
                memcpy(extra, priv->new_SSID, priv->new_SSID_size);
-               extra[priv->new_SSID_size] = '\0';
                dwrq->length = priv->new_SSID_size;
        } else {
                memcpy(extra, priv->SSID, priv->SSID_size);
-               extra[priv->SSID_size] = '\0';
                dwrq->length = priv->SSID_size;
        }
 
index 76e3aed4b4711893a4cd96fc8ef6a06af20fc35d..978ed099e2852e45fa20c08a3bebf2011b927a0e 100644 (file)
@@ -705,11 +705,30 @@ int bcm43xx_dma_init(struct bcm43xx_private *bcm)
        struct bcm43xx_dmaring *ring;
        int err = -ENOMEM;
        int dma64 = 0;
-       u32 sbtmstatehi;
+       u64 mask = bcm43xx_get_supported_dma_mask(bcm);
+       int nobits;
 
-       sbtmstatehi = bcm43xx_read32(bcm, BCM43xx_CIR_SBTMSTATEHIGH);
-       if (sbtmstatehi & BCM43xx_SBTMSTATEHIGH_DMA64BIT)
+       if (mask == DMA_64BIT_MASK) {
                dma64 = 1;
+               nobits = 64;
+       } else if (mask == DMA_32BIT_MASK)
+               nobits = 32;
+       else
+               nobits = 30;
+       err = pci_set_dma_mask(bcm->pci_dev, mask);
+       err |= pci_set_consistent_dma_mask(bcm->pci_dev, mask);
+       if (err) {
+#ifdef CONFIG_BCM43XX_PIO
+               printk(KERN_WARNING PFX "DMA not supported on this device."
+                                       " Falling back to PIO.\n");
+               bcm->__using_pio = 1;
+               return -ENOSYS;
+#else
+               printk(KERN_ERR PFX "FATAL: DMA not supported and PIO not configured. "
+                                   "Please recompile the driver with PIO support.\n");
+               return -ENODEV;
+#endif /* CONFIG_BCM43XX_PIO */
+       }
 
        /* setup TX DMA channels. */
        ring = bcm43xx_setup_dmaring(bcm, 0, 1, dma64);
@@ -755,8 +774,7 @@ int bcm43xx_dma_init(struct bcm43xx_private *bcm)
                dma->rx_ring3 = ring;
        }
 
-       dprintk(KERN_INFO PFX "%s DMA initialized\n",
-                       dma64 ? "64-bit" : "32-bit");
+       dprintk(KERN_INFO PFX "%d-bit DMA initialized\n", nobits);
        err = 0;
 out:
        return err;
index e04bcaddd1d004d1b514a39bf047f11a963e1bbf..ea16078cfe98bd95169e626b203a77194a935ace 100644 (file)
@@ -314,6 +314,23 @@ int bcm43xx_dma_tx(struct bcm43xx_private *bcm,
                   struct ieee80211_txb *txb);
 void bcm43xx_dma_rx(struct bcm43xx_dmaring *ring);
 
+/* Helper function that returns the dma mask for this device. */
+static inline
+u64 bcm43xx_get_supported_dma_mask(struct bcm43xx_private *bcm)
+{
+       int dma64 = bcm43xx_read32(bcm, BCM43xx_CIR_SBTMSTATEHIGH) &
+                                  BCM43xx_SBTMSTATEHIGH_DMA64BIT;
+       u16 mmio_base = bcm43xx_dmacontroller_base(dma64, 0);
+       u32 mask = BCM43xx_DMA32_TXADDREXT_MASK;
+
+       if (dma64)
+               return DMA_64BIT_MASK;
+       bcm43xx_write32(bcm, mmio_base + BCM43xx_DMA32_TXCTL, mask);
+       if (bcm43xx_read32(bcm, mmio_base + BCM43xx_DMA32_TXCTL) & mask)
+               return DMA_32BIT_MASK;
+       return DMA_30BIT_MASK;
+}
+
 #else /* CONFIG_BCM43XX_DMA */
 
 
index c3f90c8563d915ee4175afe6ca8cd6a4a41627fb..2ddbec6bf15b878449e1e15b0d06e3e18d36dbbc 100644 (file)
@@ -242,7 +242,7 @@ void bcm43xx_leds_update(struct bcm43xx_private *bcm, int activity)
                        //TODO
                        break;
                case BCM43xx_LED_ASSOC:
-                       if (bcm->softmac->associated)
+                       if (bcm->softmac->associnfo.associated)
                                turn_on = 1;
                        break;
 #ifdef CONFIG_BCM43XX_DEBUG
index bad3452ea8930479af96d3791f905855e89f8bf1..a94c6d8826f874e7c4606fa6884491da897a45cf 100644 (file)
@@ -2925,10 +2925,13 @@ static int bcm43xx_wireless_core_init(struct bcm43xx_private *bcm,
                bcm43xx_write16(bcm, 0x043C, 0x000C);
 
        if (active_wlcore) {
-               if (bcm43xx_using_pio(bcm))
+               if (bcm43xx_using_pio(bcm)) {
                        err = bcm43xx_pio_init(bcm);
-               else
+               } else {
                        err = bcm43xx_dma_init(bcm);
+                       if (err == -ENOSYS)
+                               err = bcm43xx_pio_init(bcm);
+               }
                if (err)
                        goto err_chip_cleanup;
        }
@@ -3164,12 +3167,12 @@ static void bcm43xx_periodic_work_handler(void *d)
        u32 savedirqs = 0;
        int badness;
 
+       mutex_lock(&bcm->mutex);
        badness = estimate_periodic_work_badness(bcm->periodic_state);
        if (badness > BADNESS_LIMIT) {
                /* Periodic work will take a long time, so we want it to
                 * be preemtible.
                 */
-               mutex_lock(&bcm->mutex);
                netif_tx_disable(bcm->net_dev);
                spin_lock_irqsave(&bcm->irq_lock, flags);
                bcm43xx_mac_suspend(bcm);
@@ -3182,7 +3185,6 @@ static void bcm43xx_periodic_work_handler(void *d)
                /* Periodic work should take short time, so we want low
                 * locking overhead.
                 */
-               mutex_lock(&bcm->mutex);
                spin_lock_irqsave(&bcm->irq_lock, flags);
        }
 
@@ -3993,8 +3995,6 @@ static int bcm43xx_init_private(struct bcm43xx_private *bcm,
                                struct net_device *net_dev,
                                struct pci_dev *pci_dev)
 {
-       int err;
-
        bcm43xx_set_status(bcm, BCM43xx_STAT_UNINIT);
        bcm->ieee = netdev_priv(net_dev);
        bcm->softmac = ieee80211_priv(net_dev);
@@ -4012,22 +4012,8 @@ static int bcm43xx_init_private(struct bcm43xx_private *bcm,
                     (void (*)(unsigned long))bcm43xx_interrupt_tasklet,
                     (unsigned long)bcm);
        tasklet_disable_nosync(&bcm->isr_tasklet);
-       if (modparam_pio) {
+       if (modparam_pio)
                bcm->__using_pio = 1;
-       } else {
-               err = pci_set_dma_mask(pci_dev, DMA_30BIT_MASK);
-               err |= pci_set_consistent_dma_mask(pci_dev, DMA_30BIT_MASK);
-               if (err) {
-#ifdef CONFIG_BCM43XX_PIO
-                       printk(KERN_WARNING PFX "DMA not supported. Falling back to PIO.\n");
-                       bcm->__using_pio = 1;
-#else
-                       printk(KERN_ERR PFX "FATAL: DMA not supported and PIO not configured. "
-                                           "Recompile the driver with PIO support, please.\n");
-                       return -ENODEV;
-#endif /* CONFIG_BCM43XX_PIO */
-               }
-       }
        bcm->rts_threshold = BCM43xx_DEFAULT_RTS_THRESHOLD;
 
        /* default to sw encryption for now */
@@ -4208,7 +4194,11 @@ static int bcm43xx_resume(struct pci_dev *pdev)
        dprintk(KERN_INFO PFX "Resuming...\n");
 
        pci_set_power_state(pdev, 0);
-       pci_enable_device(pdev);
+       err = pci_enable_device(pdev);
+       if (err) {
+               printk(KERN_ERR PFX "Failure with pci_enable_device!\n");
+               return err;
+       }
        pci_restore_state(pdev);
 
        bcm43xx_chipset_attach(bcm);
index 9b7b15cf656153b20d99633019b1885a1b87513c..d27016f8c736bb77def6401028716808d870bdaa 100644 (file)
@@ -847,7 +847,7 @@ static struct iw_statistics *bcm43xx_get_wireless_stats(struct net_device *net_d
        unsigned long flags;
 
        wstats = &bcm->stats.wstats;
-       if (!mac->associated) {
+       if (!mac->associnfo.associated) {
                wstats->miss.beacon = 0;
 //             bcm->ieee->ieee_stats.tx_retry_limit_exceeded = 0; // FIXME: should this be cleared here?
                wstats->discard.retries = 0;
index b779c7dcc1a84b55e7eafa8285b3038fc015ad2e..336cabac13b392a584259f2a045bc7e673275be1 100644 (file)
@@ -2457,6 +2457,7 @@ void free_orinocodev(struct net_device *dev)
 /* Wireless extensions                                              */
 /********************************************************************/
 
+/* Return : < 0 -> error code ; >= 0 -> length */
 static int orinoco_hw_get_essid(struct orinoco_private *priv, int *active,
                                char buf[IW_ESSID_MAX_SIZE+1])
 {
@@ -2501,9 +2502,9 @@ static int orinoco_hw_get_essid(struct orinoco_private *priv, int *active,
        len = le16_to_cpu(essidbuf.len);
        BUG_ON(len > IW_ESSID_MAX_SIZE);
 
-       memset(buf, 0, IW_ESSID_MAX_SIZE+1);
+       memset(buf, 0, IW_ESSID_MAX_SIZE);
        memcpy(buf, p, len);
-       buf[len] = '\0';
+       err = len;
 
  fail_unlock:
        orinoco_unlock(priv, &flags);
@@ -3027,17 +3028,18 @@ static int orinoco_ioctl_getessid(struct net_device *dev,
 
        if (netif_running(dev)) {
                err = orinoco_hw_get_essid(priv, &active, essidbuf);
-               if (err)
+               if (err < 0)
                        return err;
+               erq->length = err;
        } else {
                if (orinoco_lock(priv, &flags) != 0)
                        return -EBUSY;
-               memcpy(essidbuf, priv->desired_essid, IW_ESSID_MAX_SIZE + 1);
+               memcpy(essidbuf, priv->desired_essid, IW_ESSID_MAX_SIZE);
+               erq->length = strlen(priv->desired_essid);
                orinoco_unlock(priv, &flags);
        }
 
        erq->flags = 1;
-       erq->length = strlen(essidbuf);
 
        return 0;
 }
@@ -3075,10 +3077,10 @@ static int orinoco_ioctl_getnick(struct net_device *dev,
        if (orinoco_lock(priv, &flags) != 0)
                return -EBUSY;
 
-       memcpy(nickbuf, priv->nick, IW_ESSID_MAX_SIZE+1);
+       memcpy(nickbuf, priv->nick, IW_ESSID_MAX_SIZE);
        orinoco_unlock(priv, &flags);
 
-       nrq->length = strlen(nickbuf);
+       nrq->length = strlen(priv->nick);
 
        return 0;
 }
index 0b381d77015c99981f04862ed3a707d40f2798d7..7fbfc9e41d07b804dea4c7704d95da10f459f69c 100644 (file)
@@ -1198,7 +1198,6 @@ static int ray_get_essid(struct net_device *dev,
 
        /* Get the essid that was set */
        memcpy(extra, local->sparm.b5.a_current_ess_id, IW_ESSID_MAX_SIZE);
-       extra[IW_ESSID_MAX_SIZE] = '\0';
 
        /* Push it out ! */
        dwrq->length = strlen(extra);
index 30057a335a7bc6ccb17b6e645f718485fa70453d..36b29ff058141a712619e55184566b39ce414efd 100644 (file)
@@ -193,10 +193,8 @@ static void zd1201_usbrx(struct urb *urb)
        struct sk_buff *skb;
        unsigned char type;
 
-       if (!zd) {
-               free = 1;
-               goto exit;
-       }
+       if (!zd)
+               return;
 
        switch(urb->status) {
                case -EILSEQ:
index 2d12837052b03f35f49e1f4ae21aa99c831653f7..a7d29bddb298a7a7d41cc1edeb3753d15bae7037 100644 (file)
@@ -1099,7 +1099,7 @@ static void link_led_handler(void *p)
        int r;
 
        spin_lock_irq(&mac->lock);
-       is_associated = sm->associated != 0;
+       is_associated = sm->associnfo.associated != 0;
        spin_unlock_irq(&mac->lock);
 
        r = zd_chip_control_leds(chip,
index 425b3a57ac74a01d12f8f3d714b66cd9d7dbcb04..617b672b1132e7fa3ff5f9c940b1692520dc8483 100644 (file)
@@ -63,13 +63,11 @@ struct ieee80211softmac_wpa {
 
 /*
  * Information about association
- *
- * Do we need a lock for this?
- * We only ever use this structure inlined
- * into our global struct. I've used its lock,
- * but maybe we need a local one here?
  */
 struct ieee80211softmac_assoc_info {
+
+       struct mutex mutex;
+
        /*
         * This is the requested ESSID. It is written
         * only by the WX handlers.
@@ -99,12 +97,13 @@ struct ieee80211softmac_assoc_info {
         *
         * bssfixed is used for SIOCSIWAP.
         */
-       u8 static_essid:1,
-          short_preamble_available:1,
-          associating:1,
-          assoc_wait:1,
-          bssvalid:1,
-          bssfixed:1;
+       u8 static_essid;
+       u8 short_preamble_available;
+       u8 associating;
+       u8 associated;
+       u8 assoc_wait;
+       u8 bssvalid;
+       u8 bssfixed;
 
        /* Scan retries remaining */
        int scan_retry;
@@ -229,12 +228,10 @@ struct ieee80211softmac_device {
        /* private stuff follows */
        /* this lock protects this structure */
        spinlock_t lock;
-       
-       /* couple of flags */
-       u8 scanning:1, /* protects scanning from being done multiple times at once */
-          associated:1,
-          running:1;
-       
+
+       u8 running; /* SoftMAC started? */
+       u8 scanning;
+
        struct ieee80211softmac_scaninfo *scaninfo;
        struct ieee80211softmac_assoc_info associnfo;
        struct ieee80211softmac_bss_info bssinfo;
@@ -250,7 +247,7 @@ struct ieee80211softmac_device {
 
        /* we need to keep a list of network structs we copied */
        struct list_head network_list;
-       
+
        /* This must be the last item so that it points to the data
         * allocated beyond this structure by alloc_ieee80211 */
        u8 priv[0];
@@ -295,7 +292,7 @@ static inline u8 ieee80211softmac_suggest_txrate(struct ieee80211softmac_device
 {
        struct ieee80211softmac_txrates *txrates = &mac->txrates;
 
-       if (!mac->associated)
+       if (!mac->associnfo.associated)
                return txrates->mgt_mcast_rate;
 
        /* We are associated, sending unicast frame */
index ffff0da46c6ee2a3703a9f3116eab0162b4727e6..cb1b8728d7eec0c55c6151da9fba7d00f42747e9 100644 (file)
@@ -748,11 +748,39 @@ static int ioctl_standard_call(struct net_device *        dev,
                int     extra_size;
                int     user_length = 0;
                int     err;
+               int     essid_compat = 0;
 
                /* Calculate space needed by arguments. Always allocate
                 * for max space. Easier, and won't last long... */
                extra_size = descr->max_tokens * descr->token_size;
 
+               /* Check need for ESSID compatibility for WE < 21 */
+               switch (cmd) {
+               case SIOCSIWESSID:
+               case SIOCGIWESSID:
+               case SIOCSIWNICKN:
+               case SIOCGIWNICKN:
+                       if (iwr->u.data.length == descr->max_tokens + 1)
+                               essid_compat = 1;
+                       else if (IW_IS_SET(cmd) && (iwr->u.data.length != 0)) {
+                               char essid[IW_ESSID_MAX_SIZE + 1];
+
+                               err = copy_from_user(essid, iwr->u.data.pointer,
+                                                    iwr->u.data.length *
+                                                    descr->token_size);
+                               if (err)
+                                       return -EFAULT;
+
+                               if (essid[iwr->u.data.length - 1] == '\0')
+                                       essid_compat = 1;
+                       }
+                       break;
+               default:
+                       break;
+               }
+
+               iwr->u.data.length -= essid_compat;
+
                /* Check what user space is giving us */
                if(IW_IS_SET(cmd)) {
                        /* Check NULL pointer */
@@ -795,7 +823,8 @@ static int ioctl_standard_call(struct net_device *  dev,
 #endif /* WE_IOCTL_DEBUG */
 
                /* Create the kernel buffer */
-               extra = kmalloc(extra_size, GFP_KERNEL);
+               /*    kzalloc ensures NULL-termination for essid_compat */
+               extra = kzalloc(extra_size, GFP_KERNEL);
                if (extra == NULL) {
                        return -ENOMEM;
                }
@@ -819,6 +848,8 @@ static int ioctl_standard_call(struct net_device *  dev,
                /* Call the handler */
                ret = handler(dev, &info, &(iwr->u), extra);
 
+               iwr->u.data.length += essid_compat;
+
                /* If we have something to return to the user */
                if (!ret && IW_IS_GET(cmd)) {
                        /* Check if there is enough buffer up there */
index 589f6d2c548a7ba0167598def59daab5b7eb13c4..cf51c87a971d786f0035b7e5d34cc6076889cc23 100644 (file)
@@ -48,7 +48,7 @@ ieee80211softmac_assoc(struct ieee80211softmac_device *mac, struct ieee80211soft
        dprintk(KERN_INFO PFX "sent association request!\n");
 
        spin_lock_irqsave(&mac->lock, flags);
-       mac->associated = 0; /* just to make sure */
+       mac->associnfo.associated = 0; /* just to make sure */
 
        /* Set a timer for timeout */
        /* FIXME: make timeout configurable */
@@ -62,24 +62,22 @@ ieee80211softmac_assoc_timeout(void *d)
 {
        struct ieee80211softmac_device *mac = (struct ieee80211softmac_device *)d;
        struct ieee80211softmac_network *n;
-       unsigned long flags;
 
-       spin_lock_irqsave(&mac->lock, flags);
+       mutex_lock(&mac->associnfo.mutex);
        /* we might race against ieee80211softmac_handle_assoc_response,
         * so make sure only one of us does something */
-       if (!mac->associnfo.associating) {
-               spin_unlock_irqrestore(&mac->lock, flags);
-               return;
-       }
+       if (!mac->associnfo.associating)
+               goto out;
        mac->associnfo.associating = 0;
        mac->associnfo.bssvalid = 0;
-       mac->associated = 0;
+       mac->associnfo.associated = 0;
 
        n = ieee80211softmac_get_network_by_bssid_locked(mac, mac->associnfo.bssid);
-       spin_unlock_irqrestore(&mac->lock, flags);
 
        dprintk(KERN_INFO PFX "assoc request timed out!\n");
        ieee80211softmac_call_events(mac, IEEE80211SOFTMAC_EVENT_ASSOCIATE_TIMEOUT, n);
+out:
+       mutex_unlock(&mac->associnfo.mutex);
 }
 
 void
@@ -93,7 +91,7 @@ ieee80211softmac_disassoc(struct ieee80211softmac_device *mac)
 
        netif_carrier_off(mac->dev);
 
-       mac->associated = 0;
+       mac->associnfo.associated = 0;
        mac->associnfo.bssvalid = 0;
        mac->associnfo.associating = 0;
        ieee80211softmac_init_bss(mac);
@@ -107,7 +105,7 @@ ieee80211softmac_send_disassoc_req(struct ieee80211softmac_device *mac, u16 reas
 {
        struct ieee80211softmac_network *found;
 
-       if (mac->associnfo.bssvalid && mac->associated) {
+       if (mac->associnfo.bssvalid && mac->associnfo.associated) {
                found = ieee80211softmac_get_network_by_bssid(mac, mac->associnfo.bssid);
                if (found)
                        ieee80211softmac_send_mgt_frame(mac, found, IEEE80211_STYPE_DISASSOC, reason);
@@ -196,17 +194,18 @@ ieee80211softmac_assoc_work(void *d)
        int bssvalid;
        unsigned long flags;
 
+       mutex_lock(&mac->associnfo.mutex);
+
+       if (!mac->associnfo.associating)
+               goto out;
+
        /* ieee80211_disassoc might clear this */
        bssvalid = mac->associnfo.bssvalid;
 
        /* meh */
-       if (mac->associated)
+       if (mac->associnfo.associated)
                ieee80211softmac_send_disassoc_req(mac, WLAN_REASON_DISASSOC_STA_HAS_LEFT);
 
-       spin_lock_irqsave(&mac->lock, flags);
-       mac->associnfo.associating = 1;
-       spin_unlock_irqrestore(&mac->lock, flags);
-
        /* try to find the requested network in our list, if we found one already */
        if (bssvalid || mac->associnfo.bssfixed)
                found = ieee80211softmac_get_network_by_bssid(mac, mac->associnfo.bssid);       
@@ -260,10 +259,8 @@ ieee80211softmac_assoc_work(void *d)
 
        if (!found) {
                if (mac->associnfo.scan_retry > 0) {
-                       spin_lock_irqsave(&mac->lock, flags);
                        mac->associnfo.scan_retry--;
-                       spin_unlock_irqrestore(&mac->lock, flags);
-               
+
                        /* We know of no such network. Let's scan. 
                         * NB: this also happens if we had no memory to copy the network info...
                         * Maybe we can hope to have more memory after scanning finishes ;)
@@ -272,19 +269,17 @@ ieee80211softmac_assoc_work(void *d)
                        ieee80211softmac_notify(mac->dev, IEEE80211SOFTMAC_EVENT_SCAN_FINISHED, ieee80211softmac_assoc_notify_scan, NULL);
                        if (ieee80211softmac_start_scan(mac))
                                dprintk(KERN_INFO PFX "Associate: failed to initiate scan. Is device up?\n");
-                       return;
+                       goto out;
                } else {
-                       spin_lock_irqsave(&mac->lock, flags);
                        mac->associnfo.associating = 0;
-                       mac->associated = 0;
-                       spin_unlock_irqrestore(&mac->lock, flags);
+                       mac->associnfo.associated = 0;
 
                        dprintk(KERN_INFO PFX "Unable to find matching network after scan!\n");
                        /* reset the retry counter for the next user request since we
                         * break out and don't reschedule ourselves after this point. */
                        mac->associnfo.scan_retry = IEEE80211SOFTMAC_ASSOC_SCAN_RETRY_LIMIT;
                        ieee80211softmac_call_events(mac, IEEE80211SOFTMAC_EVENT_ASSOCIATE_NET_NOT_FOUND, NULL);
-                       return;
+                       goto out;
                }
        }
 
@@ -297,7 +292,7 @@ ieee80211softmac_assoc_work(void *d)
        /* copy the ESSID for displaying it */
        mac->associnfo.associate_essid.len = found->essid.len;
        memcpy(mac->associnfo.associate_essid.data, found->essid.data, IW_ESSID_MAX_SIZE + 1);
-       
+
        /* we found a network! authenticate (if necessary) and associate to it. */
        if (found->authenticating) {
                dprintk(KERN_INFO PFX "Already requested authentication, waiting...\n");
@@ -305,7 +300,7 @@ ieee80211softmac_assoc_work(void *d)
                        mac->associnfo.assoc_wait = 1;
                        ieee80211softmac_notify_internal(mac, IEEE80211SOFTMAC_EVENT_ANY, found, ieee80211softmac_assoc_notify_auth, NULL, GFP_KERNEL);
                }
-               return;
+               goto out;
        }
        if (!found->authenticated && !found->authenticating) {
                /* This relies on the fact that _auth_req only queues the work,
@@ -321,11 +316,14 @@ ieee80211softmac_assoc_work(void *d)
                        mac->associnfo.assoc_wait = 0;
                        ieee80211softmac_call_events(mac, IEEE80211SOFTMAC_EVENT_ASSOCIATE_FAILED, found);
                }
-               return;
+               goto out;
        }
        /* finally! now we can start associating */
        mac->associnfo.assoc_wait = 0;
        ieee80211softmac_assoc(mac, found);
+
+out:
+       mutex_unlock(&mac->associnfo.mutex);
 }
 
 /* call this to do whatever is necessary when we're associated */
@@ -341,7 +339,7 @@ ieee80211softmac_associated(struct ieee80211softmac_device *mac,
        mac->bssinfo.supported_rates = net->supported_rates;
        ieee80211softmac_recalc_txrates(mac);
 
-       mac->associated = 1;
+       mac->associnfo.associated = 1;
 
        mac->associnfo.short_preamble_available =
                (cap & WLAN_CAPABILITY_SHORT_PREAMBLE) != 0;
@@ -421,7 +419,7 @@ ieee80211softmac_handle_assoc_response(struct net_device * dev,
                        dprintk(KERN_INFO PFX "associating failed (reason: 0x%x)!\n", status);
                        mac->associnfo.associating = 0;
                        mac->associnfo.bssvalid = 0;
-                       mac->associated = 0;
+                       mac->associnfo.associated = 0;
                        ieee80211softmac_call_events_locked(mac, IEEE80211SOFTMAC_EVENT_ASSOCIATE_FAILED, network);
        }
        
index 82bfddbf33a28e999b944d86660f21560206438b..b96931001b43d131bc30d8d7841fda97b0897ce0 100644 (file)
@@ -304,7 +304,7 @@ ieee80211softmac_auth(struct ieee80211_auth **pkt,
                2 +             /* Auth Transaction Seq */
                2 +             /* Status Code */
                 /* Challenge Text IE */
-               is_shared_response ? 0 : 1 + 1 + net->challenge_len
+               (is_shared_response ? 1 + 1 + net->challenge_len : 0)
        );
        if (unlikely((*pkt) == NULL))
                return 0;
@@ -475,8 +475,13 @@ int ieee80211softmac_handle_beacon(struct net_device *dev,
 {
        struct ieee80211softmac_device *mac = ieee80211_priv(dev);
 
-       if (mac->associated && memcmp(network->bssid, mac->associnfo.bssid, ETH_ALEN) == 0)
-               ieee80211softmac_process_erp(mac, network->erp_value);
+       /* This might race, but we don't really care and it's not worth
+        * adding heavyweight locking in this fastpath.
+        */
+       if (mac->associnfo.associated) {
+               if (memcmp(network->bssid, mac->associnfo.bssid, ETH_ALEN) == 0)
+                       ieee80211softmac_process_erp(mac, network->erp_value);
+       }
 
        return 0;
 }
index addea1cf73ae3f5ba9f2787af8503bb354b97778..33aff4f4a471fde8fe6538c46dbe8527c48536a6 100644 (file)
@@ -57,6 +57,7 @@ struct net_device *alloc_ieee80211softmac(int sizeof_priv)
        INIT_LIST_HEAD(&softmac->network_list);
        INIT_LIST_HEAD(&softmac->events);
 
+       mutex_init(&softmac->associnfo.mutex);
        INIT_WORK(&softmac->associnfo.work, ieee80211softmac_assoc_work, softmac);
        INIT_WORK(&softmac->associnfo.timeout, ieee80211softmac_assoc_timeout, softmac);
        softmac->start_scan = ieee80211softmac_start_scan_implementation;
index 2aa779d18f3861a2f6f2119f99c89c6c2c56b583..23068a830f7dba7916c0380ef1767758d1f95815 100644 (file)
@@ -73,13 +73,14 @@ ieee80211softmac_wx_set_essid(struct net_device *net_dev,
        struct ieee80211softmac_network *n;
        struct ieee80211softmac_auth_queue_item *authptr;
        int length = 0;
-       unsigned long flags;
+
+       mutex_lock(&sm->associnfo.mutex);
 
        /* Check if we're already associating to this or another network
         * If it's another network, cancel and start over with our new network
         * If it's our network, ignore the change, we're already doing it!
         */
-       if((sm->associnfo.associating || sm->associated) &&
+       if((sm->associnfo.associating || sm->associnfo.associated) &&
           (data->essid.flags && data->essid.length)) {
                /* Get the associating network */
                n = ieee80211softmac_get_network_by_bssid(sm, sm->associnfo.bssid);
@@ -87,10 +88,9 @@ ieee80211softmac_wx_set_essid(struct net_device *net_dev,
                   !memcmp(n->essid.data, extra, n->essid.len)) {
                        dprintk(KERN_INFO PFX "Already associating or associated to "MAC_FMT"\n",
                                MAC_ARG(sm->associnfo.bssid));
-                       return 0;
+                       goto out;
                } else {
                        dprintk(KERN_INFO PFX "Canceling existing associate request!\n");
-                       spin_lock_irqsave(&sm->lock,flags);
                        /* Cancel assoc work */
                        cancel_delayed_work(&sm->associnfo.work);
                        /* We don't have to do this, but it's a little cleaner */
@@ -98,14 +98,13 @@ ieee80211softmac_wx_set_essid(struct net_device *net_dev,
                                cancel_delayed_work(&authptr->work);
                        sm->associnfo.bssvalid = 0;
                        sm->associnfo.bssfixed = 0;
-                       spin_unlock_irqrestore(&sm->lock,flags);
                        flush_scheduled_work();
+                       sm->associnfo.associating = 0;
+                       sm->associnfo.associated = 0;
                }
        }
 
 
-       spin_lock_irqsave(&sm->lock, flags);
-
        sm->associnfo.static_essid = 0;
        sm->associnfo.assoc_wait = 0;
 
@@ -121,10 +120,12 @@ ieee80211softmac_wx_set_essid(struct net_device *net_dev,
         * If applicable, we have already copied the data in */
        sm->associnfo.req_essid.len = length;
 
+       sm->associnfo.associating = 1;
        /* queue lower level code to do work (if necessary) */
        schedule_work(&sm->associnfo.work);
+out:
+       mutex_unlock(&sm->associnfo.mutex);
 
-       spin_unlock_irqrestore(&sm->lock, flags);
        return 0;
 }
 EXPORT_SYMBOL_GPL(ieee80211softmac_wx_set_essid);
@@ -136,10 +137,8 @@ ieee80211softmac_wx_get_essid(struct net_device *net_dev,
                              char *extra)
 {
        struct ieee80211softmac_device *sm = ieee80211_priv(net_dev);
-       unsigned long flags;
 
-       /* avoid getting inconsistent information */
-       spin_lock_irqsave(&sm->lock, flags);
+       mutex_lock(&sm->associnfo.mutex);
        /* If all fails, return ANY (empty) */
        data->essid.length = 0;
        data->essid.flags = 0;  /* active */
@@ -152,12 +151,13 @@ ieee80211softmac_wx_get_essid(struct net_device *net_dev,
        }
        
        /* If we're associating/associated, return that */
-       if (sm->associated || sm->associnfo.associating) {
+       if (sm->associnfo.associated || sm->associnfo.associating) {
                data->essid.length = sm->associnfo.associate_essid.len;
                data->essid.flags = 1;  /* active */
                memcpy(extra, sm->associnfo.associate_essid.data, sm->associnfo.associate_essid.len);
        }
-       spin_unlock_irqrestore(&sm->lock, flags);
+       mutex_unlock(&sm->associnfo.mutex);
+
        return 0;
 }
 EXPORT_SYMBOL_GPL(ieee80211softmac_wx_get_essid);
@@ -322,15 +322,15 @@ ieee80211softmac_wx_get_wap(struct net_device *net_dev,
 {
        struct ieee80211softmac_device *mac = ieee80211_priv(net_dev);
        int err = 0;
-       unsigned long flags;
 
-       spin_lock_irqsave(&mac->lock, flags);
+       mutex_lock(&mac->associnfo.mutex);
        if (mac->associnfo.bssvalid)
                memcpy(data->ap_addr.sa_data, mac->associnfo.bssid, ETH_ALEN);
        else
                memset(data->ap_addr.sa_data, 0xff, ETH_ALEN);
        data->ap_addr.sa_family = ARPHRD_ETHER;
-       spin_unlock_irqrestore(&mac->lock, flags);
+       mutex_unlock(&mac->associnfo.mutex);
+
        return err;
 }
 EXPORT_SYMBOL_GPL(ieee80211softmac_wx_get_wap);
@@ -342,28 +342,27 @@ ieee80211softmac_wx_set_wap(struct net_device *net_dev,
                            char *extra)
 {
        struct ieee80211softmac_device *mac = ieee80211_priv(net_dev);
-       unsigned long flags;
 
        /* sanity check */
        if (data->ap_addr.sa_family != ARPHRD_ETHER) {
                return -EINVAL;
        }
 
-       spin_lock_irqsave(&mac->lock, flags);
+       mutex_lock(&mac->associnfo.mutex);
        if (is_broadcast_ether_addr(data->ap_addr.sa_data)) {
                /* the bssid we have is not to be fixed any longer,
                 * and we should reassociate to the best AP. */
                mac->associnfo.bssfixed = 0;
                /* force reassociation */
                mac->associnfo.bssvalid = 0;
-               if (mac->associated)
+               if (mac->associnfo.associated)
                        schedule_work(&mac->associnfo.work);
        } else if (is_zero_ether_addr(data->ap_addr.sa_data)) {
                /* the bssid we have is no longer fixed */
                mac->associnfo.bssfixed = 0;
         } else {
                if (!memcmp(mac->associnfo.bssid, data->ap_addr.sa_data, ETH_ALEN)) {
-                       if (mac->associnfo.associating || mac->associated) {
+                       if (mac->associnfo.associating || mac->associnfo.associated) {
                        /* bssid unchanged and associated or associating - just return */
                                goto out;
                        }
@@ -378,7 +377,8 @@ ieee80211softmac_wx_set_wap(struct net_device *net_dev,
         }
 
  out:
-       spin_unlock_irqrestore(&mac->lock, flags);
+       mutex_unlock(&mac->associnfo.mutex);
+
        return 0;
 }
 EXPORT_SYMBOL_GPL(ieee80211softmac_wx_set_wap);
@@ -394,7 +394,8 @@ ieee80211softmac_wx_set_genie(struct net_device *dev,
        int err = 0;
        char *buf;
        int i;
-       
+
+       mutex_lock(&mac->associnfo.mutex);
        spin_lock_irqsave(&mac->lock, flags);
        /* bleh. shouldn't be locked for that kmalloc... */
 
@@ -432,6 +433,8 @@ ieee80211softmac_wx_set_genie(struct net_device *dev,
 
  out:  
        spin_unlock_irqrestore(&mac->lock, flags);
+       mutex_unlock(&mac->associnfo.mutex);
+
        return err;
 }
 EXPORT_SYMBOL_GPL(ieee80211softmac_wx_set_genie);
@@ -446,7 +449,8 @@ ieee80211softmac_wx_get_genie(struct net_device *dev,
        unsigned long flags;
        int err = 0;
        int space = wrqu->data.length;
-       
+
+       mutex_lock(&mac->associnfo.mutex);
        spin_lock_irqsave(&mac->lock, flags);
        
        wrqu->data.length = 0;
@@ -459,6 +463,8 @@ ieee80211softmac_wx_get_genie(struct net_device *dev,
                        err = -E2BIG;
        }
        spin_unlock_irqrestore(&mac->lock, flags);
+       mutex_lock(&mac->associnfo.mutex);
+
        return err;
 }
 EXPORT_SYMBOL_GPL(ieee80211softmac_wx_get_genie);
@@ -473,10 +479,13 @@ ieee80211softmac_wx_set_mlme(struct net_device *dev,
        struct iw_mlme *mlme = (struct iw_mlme *)extra;
        u16 reason = cpu_to_le16(mlme->reason_code);
        struct ieee80211softmac_network *net;
+       int err = -EINVAL;
+
+       mutex_lock(&mac->associnfo.mutex);
 
        if (memcmp(mac->associnfo.bssid, mlme->addr.sa_data, ETH_ALEN)) {
                printk(KERN_DEBUG PFX "wx_set_mlme: requested operation on net we don't use\n");
-               return -EINVAL;
+               goto out;
        }
 
        switch (mlme->cmd) {
@@ -484,14 +493,22 @@ ieee80211softmac_wx_set_mlme(struct net_device *dev,
                net = ieee80211softmac_get_network_by_bssid_locked(mac, mlme->addr.sa_data);
                if (!net) {
                        printk(KERN_DEBUG PFX "wx_set_mlme: we should know the net here...\n");
-                       return -EINVAL;
+                       goto out;
                }
                return ieee80211softmac_deauth_req(mac, net, reason);
        case IW_MLME_DISASSOC:
                ieee80211softmac_send_disassoc_req(mac, reason);
-               return 0;
+               mac->associnfo.associated = 0;
+               mac->associnfo.associating = 0;
+               err = 0;
+               goto out;
        default:
-               return -EOPNOTSUPP;
+               err = -EOPNOTSUPP;
        }
+
+out:
+       mutex_unlock(&mac->associnfo.mutex);
+
+       return err;
 }
 EXPORT_SYMBOL_GPL(ieee80211softmac_wx_set_mlme);