ath6kl_dbg(ATH6KL_DBG_HTC_SEND, "%s: transmit len : %d (%s)\n",
                   __func__, send_len, sync ? "sync" : "async");
 
-       padded_len = CALC_TXRX_PADDED_LEN(target->dev, send_len);
+       padded_len = CALC_TXRX_PADDED_LEN(target, send_len);
 
        ath6kl_dbg(ATH6KL_DBG_HTC_SEND,
                "DevSendPacket, padded len: %d mbox:0x%X (mode:%s)\n",
                        "got head pkt:0x%p , queue depth: %d\n",
                        packet, get_queue_depth(&endpoint->txq));
 
-               len = CALC_TXRX_PADDED_LEN(target->dev,
+               len = CALC_TXRX_PADDED_LEN(target,
                                           packet->act_len + HTC_HDR_LENGTH);
 
                if (htc_check_credits(target, endpoint, &flags,
                        break;
 
                packet = list_first_entry(queue, struct htc_packet, list);
-               len = CALC_TXRX_PADDED_LEN(target->dev,
+               len = CALC_TXRX_PADDED_LEN(target,
                                           packet->act_len + HTC_HDR_LENGTH);
 
                cred_pad = htc_get_credit_padding(target->tgt_cred_sz,
        u32 padded_len;
        int status;
 
-       padded_len = CALC_TXRX_PADDED_LEN(dev, rx_len);
+       padded_len = CALC_TXRX_PADDED_LEN(target, rx_len);
 
        if (padded_len > packet->buf_len) {
                ath6kl_err("not enough receive space for packet - padlen:%d recvlen:%d bufferlen:%d\n",
        int status = 0, j, full_len;
        bool no_recycle;
 
-       full_len = CALC_TXRX_PADDED_LEN(target->dev,
+       full_len = CALC_TXRX_PADDED_LEN(target,
                                        le16_to_cpu(htc_hdr->payld_len) +
                                        sizeof(*htc_hdr));
 
                packet = list_first_entry(rxq, struct htc_packet, list);
                list_del(&packet->list);
 
-               pad_len = CALC_TXRX_PADDED_LEN(target->dev,
+               pad_len = CALC_TXRX_PADDED_LEN(target,
                                                   packet->act_len);
 
                if ((rem_space - pad_len) < 0) {
        if (target->max_rx_bndl_sz)
                target->rx_bndl_enable = true;
 
-       if ((target->tgt_cred_sz % target->dev->block_sz) != 0) {
+       if ((target->tgt_cred_sz % target->block_sz) != 0) {
                ath6kl_warn("credit size: %d is not block aligned! Disabling send bundling\n",
                            target->tgt_cred_sz);
 
 
         * for SDIO the block size on mailbox 0 is artificially set to 1.
         * So we use the block size that is set for the other 3 mailboxes.
         */
-       dev->block_sz = dev->ar->mbox_info.block_size;
+       dev->htc_cnxt->block_sz = dev->ar->mbox_info.block_size;
 
        /* must be a power of 2 */
-       if ((dev->block_sz & (dev->block_sz - 1)) != 0) {
+       if ((dev->htc_cnxt->block_sz & (dev->htc_cnxt->block_sz - 1)) != 0) {
                WARN_ON(1);
                goto fail_setup;
        }
 
        /* assemble mask, used for padding to a block */
-       dev->block_mask = dev->block_sz - 1;
+       dev->htc_cnxt->block_mask = dev->htc_cnxt->block_sz - 1;
 
        ath6kl_dbg(ATH6KL_DBG_TRC, "block size: %d, mbox addr:0x%X\n",
-                  dev->block_sz, dev->ar->mbox_info.htc_addr);
+                  dev->htc_cnxt->block_sz, dev->ar->mbox_info.htc_addr);
 
        ath6kl_dbg(ATH6KL_DBG_TRC,
                   "hif interrupt processing is sync only\n");