static void hfa384x_usbctlx_reaper_task(unsigned long data);
 
-static int hfa384x_usbctlx_submit(hfa384x_t *hw, hfa384x_usbctlx_t *ctlx);
+static int hfa384x_usbctlx_submit(hfa384x_t *hw, struct hfa384x_usbctlx *ctlx);
 
-static void unlocked_usbctlx_complete(hfa384x_t *hw, hfa384x_usbctlx_t *ctlx);
+static void unlocked_usbctlx_complete(hfa384x_t *hw, struct hfa384x_usbctlx *ctlx);
 
 struct usbctlx_completor {
        int (*complete)(struct usbctlx_completor *);
 
 static int
 hfa384x_usbctlx_complete_sync(hfa384x_t *hw,
-                             hfa384x_usbctlx_t *ctlx,
+                             struct hfa384x_usbctlx *ctlx,
                              struct usbctlx_completor *completor);
 
 static int
-unlocked_usbctlx_cancel_async(hfa384x_t *hw, hfa384x_usbctlx_t *ctlx);
+unlocked_usbctlx_cancel_async(hfa384x_t *hw, struct hfa384x_usbctlx *ctlx);
 
-static void hfa384x_cb_status(hfa384x_t *hw, const hfa384x_usbctlx_t *ctlx);
+static void hfa384x_cb_status(hfa384x_t *hw, const struct hfa384x_usbctlx *ctlx);
 
 static int
 usbctlx_get_status(const struct hfa384x_usb_statusresp *cmdresp,
        return ctlx_str[s];
 };
 
-static inline hfa384x_usbctlx_t *get_active_ctlx(hfa384x_t *hw)
+static inline struct hfa384x_usbctlx *get_active_ctlx(hfa384x_t *hw)
 {
-       return list_entry(hw->ctlxq.active.next, hfa384x_usbctlx_t, list);
+       return list_entry(hw->ctlxq.active.next, struct hfa384x_usbctlx, list);
 }
 
 #ifdef DEBUG_USB
                dev_kfree_skb(skb);
 }
 
-static hfa384x_usbctlx_t *usbctlx_alloc(void)
+static struct hfa384x_usbctlx *usbctlx_alloc(void)
 {
-       hfa384x_usbctlx_t *ctlx;
+       struct hfa384x_usbctlx *ctlx;
 
        ctlx = kzalloc(sizeof(*ctlx),
                       in_interrupt() ? GFP_ATOMIC : GFP_KERNEL);
 * Call context:
 *      interrupt
 ----------------------------------------------------------------*/
-static void hfa384x_cb_status(hfa384x_t *hw, const hfa384x_usbctlx_t *ctlx)
+static void hfa384x_cb_status(hfa384x_t *hw, const struct hfa384x_usbctlx *ctlx)
 {
        if (ctlx->usercb) {
                struct hfa384x_cmdresult cmdresult;
 *      process
 ----------------------------------------------------------------*/
 static int hfa384x_usbctlx_complete_sync(hfa384x_t *hw,
-                                        hfa384x_usbctlx_t *ctlx,
+                                        struct hfa384x_usbctlx *ctlx,
                                         struct usbctlx_completor *completor)
 {
        unsigned long flags;
              ctlx_cmdcb_t cmdcb, ctlx_usercb_t usercb, void *usercb_data)
 {
        int result;
-       hfa384x_usbctlx_t *ctlx;
+       struct hfa384x_usbctlx *ctlx;
 
        ctlx = usbctlx_alloc();
        if (!ctlx) {
               ctlx_cmdcb_t cmdcb, ctlx_usercb_t usercb, void *usercb_data)
 {
        int result;
-       hfa384x_usbctlx_t *ctlx;
+       struct hfa384x_usbctlx *ctlx;
 
        ctlx = usbctlx_alloc();
        if (!ctlx) {
               ctlx_cmdcb_t cmdcb, ctlx_usercb_t usercb, void *usercb_data)
 {
        int result;
-       hfa384x_usbctlx_t *ctlx;
+       struct hfa384x_usbctlx *ctlx;
 
        ctlx = usbctlx_alloc();
        if (!ctlx) {
               ctlx_cmdcb_t cmdcb, ctlx_usercb_t usercb, void *usercb_data)
 {
        int result;
-       hfa384x_usbctlx_t *ctlx;
+       struct hfa384x_usbctlx *ctlx;
 
        ctlx = usbctlx_alloc();
        if (!ctlx) {
               ctlx_cmdcb_t cmdcb, ctlx_usercb_t usercb, void *usercb_data)
 {
        int result;
-       hfa384x_usbctlx_t *ctlx;
+       struct hfa384x_usbctlx *ctlx;
 
        pr_debug("page=0x%04x offset=0x%04x len=%d\n", page, offset, len);
 
 static void hfa384x_usbctlx_reaper_task(unsigned long data)
 {
        hfa384x_t *hw = (hfa384x_t *)data;
-       hfa384x_usbctlx_t *ctlx, *temp;
+       struct hfa384x_usbctlx *ctlx, *temp;
        unsigned long flags;
 
        spin_lock_irqsave(&hw->ctlxq.lock, flags);
 static void hfa384x_usbctlx_completion_task(unsigned long data)
 {
        hfa384x_t *hw = (hfa384x_t *)data;
-       hfa384x_usbctlx_t *ctlx, *temp;
+       struct hfa384x_usbctlx *ctlx, *temp;
        unsigned long flags;
 
        int reap = 0;
 *      Either process or interrupt, but presumably interrupt
 ----------------------------------------------------------------*/
 static int unlocked_usbctlx_cancel_async(hfa384x_t *hw,
-                                        hfa384x_usbctlx_t *ctlx)
+                                        struct hfa384x_usbctlx *ctlx)
 {
        int ret;
 
 * Call context:
 *      Either, assume interrupt
 ----------------------------------------------------------------*/
-static void unlocked_usbctlx_complete(hfa384x_t *hw, hfa384x_usbctlx_t *ctlx)
+static void unlocked_usbctlx_complete(hfa384x_t *hw, struct hfa384x_usbctlx *ctlx)
 {
        /* Timers have been stopped, and ctlx should be in
         * a terminal state. Retire it from the "active"
                goto unlock;
 
        while (!list_empty(&hw->ctlxq.pending)) {
-               hfa384x_usbctlx_t *head;
+               struct hfa384x_usbctlx *head;
                int result;
 
                /* This is the first pending command */
                head = list_entry(hw->ctlxq.pending.next,
-                                 hfa384x_usbctlx_t, list);
+                                 struct hfa384x_usbctlx, list);
 
                /* We need to split this off to avoid a race condition */
                list_move_tail(&head->list, &hw->ctlxq.active);
 static void hfa384x_usbin_ctlx(hfa384x_t *hw, union hfa384x_usbin *usbin,
                               int urb_status)
 {
-       hfa384x_usbctlx_t *ctlx;
+       struct hfa384x_usbctlx *ctlx;
        int run_queue = 0;
        unsigned long flags;
 
        int delete_resptimer = 0;
        int timer_ok = 1;
        int run_queue = 0;
-       hfa384x_usbctlx_t *ctlx;
+       struct hfa384x_usbctlx *ctlx;
        unsigned long flags;
 
        pr_debug("urb->status=%d\n", urb->status);
                 */
                hw->ctlx_urb.transfer_flags |= URB_ASYNC_UNLINK;
                if (usb_unlink_urb(&hw->ctlx_urb) == -EINPROGRESS) {
-                       hfa384x_usbctlx_t *ctlx = get_active_ctlx(hw);
+                       struct hfa384x_usbctlx *ctlx = get_active_ctlx(hw);
 
                        ctlx->state = CTLX_REQ_FAILED;
 
         * adapter has been unplugged ...
         */
        if (!list_empty(&hw->ctlxq.active)) {
-               hfa384x_usbctlx_t *ctlx = get_active_ctlx(hw);
+               struct hfa384x_usbctlx *ctlx = get_active_ctlx(hw);
 
                if (unlocked_usbctlx_cancel_async(hw, ctlx) == 0) {
                        spin_unlock_irqrestore(&hw->ctlxq.lock, flags);
 * Call context:
 *      process or interrupt
 ----------------------------------------------------------------*/
-static int hfa384x_usbctlx_submit(hfa384x_t *hw, hfa384x_usbctlx_t *ctlx)
+static int hfa384x_usbctlx_submit(hfa384x_t *hw, struct hfa384x_usbctlx *ctlx)
 {
        unsigned long flags;