u32 type = reg->type;
        u32 id = le32_to_cpu(reg->id);
        u32 num_of_ranges, i, size;
-       void *range;
+       u8 *range;
 
        /*
         * The higher part of the ID from 2 is irrelevant for
 
                }
 
                memcpy(page_address(block->fw_paging_block),
-                      image->sec[sec_idx].data + offset, len);
+                      (const u8 *)image->sec[sec_idx].data + offset, len);
                block->fw_offs = image->sec[sec_idx].offset + offset;
                dma_sync_single_for_device(fwrt->trans->dev,
                                           block->fw_paging_phys,
 
                                        sizeof(struct iwl_wowlan_kek_kck_material_cmd_v2);
                        /* skip the sta_id at the beginning */
                        _kek_kck_cmd = (void *)
-                               ((u8 *)_kek_kck_cmd) + sizeof(kek_kck_cmd.sta_id);
+                               ((u8 *)_kek_kck_cmd + sizeof(kek_kck_cmd.sta_id));
                }
 
                IWL_DEBUG_WOWLAN(mvm, "setting akm %d\n",
 
                goto out;
        }
 
-       ret = len - copy_to_user(user_buf, (void *)rsp->data + delta, len);
+       ret = len - copy_to_user(user_buf, (u8 *)rsp->data + delta, len);
        *ppos += ret;
 
 out:
 
                mvm->nvm_data->bands[0].n_channels = 1;
                mvm->nvm_data->bands[0].n_bitrates = 1;
                mvm->nvm_data->bands[0].bitrates =
-                       (void *)mvm->nvm_data->channels + 1;
+                       (void *)((u8 *)mvm->nvm_data->channels + 1);
                mvm->nvm_data->bands[0].bitrates->hw_value = 10;
        }
 
 
        fraglen = len - hdrlen;
 
        if (fraglen) {
-               int offset = (void *)hdr + hdrlen -
-                            rxb_addr(rxb) + rxb_offset(rxb);
+               int offset = (u8 *)hdr + hdrlen -
+                            (u8 *)rxb_addr(rxb) + rxb_offset(rxb);
 
                skb_add_rx_frag(skb, 0, rxb_steal_page(rxb), offset,
                                fraglen, rxb->truesize);
 
        fraglen = len - headlen;
 
        if (fraglen) {
-               int offset = (void *)hdr + headlen + pad_len -
-                            rxb_addr(rxb) + rxb_offset(rxb);
+               int offset = (u8 *)hdr + headlen + pad_len -
+                            (u8 *)rxb_addr(rxb) + rxb_offset(rxb);
 
                skb_add_rx_frag(skb, 0, rxb_steal_page(rxb), offset,
                                fraglen, rxb->truesize);
 
        struct iwl_scan_req_umac *cmd = mvm->scan_cmd;
        struct iwl_scan_umac_chan_param *chan_param;
        void *cmd_data = iwl_mvm_get_scan_req_umac_data(mvm);
-       void *sec_part = cmd_data + sizeof(struct iwl_scan_channel_cfg_umac) *
+       void *sec_part = (u8 *)cmd_data + sizeof(struct iwl_scan_channel_cfg_umac) *
                mvm->fw->ucode_capa.n_scan_channels;
        struct iwl_scan_req_umac_tail_v2 *tail_v2 =
                (struct iwl_scan_req_umac_tail_v2 *)sec_part;
 
 
        /* PCI bus related data */
        struct pci_dev *pci_dev;
-       void __iomem *hw_base;
+       u8 __iomem *hw_base;
 
        bool ucode_write_complete;
        bool sx_complete;
 
                        goto err;
        }
 
-       rxq->rb_stts = trans_pcie->base_rb_stts + rxq->id * rb_stts_size;
+       rxq->rb_stts = (u8 *)trans_pcie->base_rb_stts + rxq->id * rb_stts_size;
        rxq->rb_stts_dma =
                trans_pcie->base_rb_stts_dma + rxq->id * rb_stts_size;
 
 
 {
        struct iwl_trans *trans = file->private_data;
        struct iwl_trans_pcie *trans_pcie = IWL_TRANS_GET_PCIE_TRANS(trans);
-       void *cpu_addr = (void *)trans->dbg.fw_mon.block, *curr_buf;
+       u8 *cpu_addr = (void *)trans->dbg.fw_mon.block, *curr_buf;
        struct cont_rec *data = &trans_pcie->fw_mon_data;
        u32 write_ptr_addr, wrap_cnt_addr, write_ptr, wrap_cnt;
        ssize_t size, bytes_copied = 0;
 
        void *tfd;
        u32 num_tbs;
 
-       tfd = txq->tfds + trans->txqs.tfd.size * txq->write_ptr;
+       tfd = (u8 *)txq->tfds + trans->txqs.tfd.size * txq->write_ptr;
 
        if (reset)
                memset(tfd, 0, trans->txqs.tfd.size);
 
                return NULL;
 
        /* set the chaining pointer to the previous page if there */
-       *(void **)(page_address(ret) + PAGE_SIZE - sizeof(void *)) = *page_ptr;
+       *(void **)((u8 *)page_address(ret) + PAGE_SIZE - sizeof(void *)) = *page_ptr;
        *page_ptr = ret;
 
        return ret;
                return NULL;
        p->pos = page_address(p->page);
        /* set the chaining pointer to NULL */
-       *(void **)(page_address(p->page) + PAGE_SIZE - sizeof(void *)) = NULL;
+       *(void **)((u8 *)page_address(p->page) + PAGE_SIZE - sizeof(void *)) = NULL;
 out:
        *page_ptr = p->page;
        get_page(p->page);
        while (next) {
                struct page *tmp = next;
 
-               next = *(void **)(page_address(next) + PAGE_SIZE -
+               next = *(void **)((u8 *)page_address(next) + PAGE_SIZE -
                                  sizeof(void *));
                __free_page(tmp);
        }
 
        if (trans->trans_cfg->use_tfh)
                idx = iwl_txq_get_cmd_index(txq, idx);
 
-       return txq->tfds + trans->txqs.tfd.size * idx;
+       return (u8 *)txq->tfds + trans->txqs.tfd.size * idx;
 }
 
 int iwl_txq_alloc(struct iwl_trans *trans, struct iwl_txq *txq, int slots_num,