* iwl3945_hw_build_tx_cmd_rate - Add rate portion to TX_CMD:
  *
 */
-void iwl3945_hw_build_tx_cmd_rate(struct iwl_priv *priv,
-                             struct iwl3945_cmd *cmd,
+void iwl3945_hw_build_tx_cmd_rate(struct iwl_priv *priv, struct iwl_cmd *cmd,
                              struct ieee80211_tx_info *info,
                              struct ieee80211_hdr *hdr, int sta_id, int tx_id)
 {
        u8 data_retry_limit;
        __le32 tx_flags;
        __le16 fc = hdr->frame_control;
+       struct iwl3945_tx_cmd *tx = (struct iwl3945_tx_cmd *)cmd->cmd.payload;
 
        rate = iwl3945_rates[rate_index].plcp;
-       tx_flags = cmd->cmd.tx.tx_flags;
+       tx_flags = tx->tx_flags;
 
        /* We need to figure out how to get the sta->supp_rates while
         * in this running context */
                }
        }
 
-       cmd->cmd.tx.rts_retry_limit = rts_retry_limit;
-       cmd->cmd.tx.data_retry_limit = data_retry_limit;
-       cmd->cmd.tx.rate = rate;
-       cmd->cmd.tx.tx_flags = tx_flags;
+       tx->rts_retry_limit = rts_retry_limit;
+       tx->data_retry_limit = data_retry_limit;
+       tx->rate = rate;
+       tx->tx_flags = tx_flags;
 
        /* OFDM */
-       cmd->cmd.tx.supp_rates[0] =
+       tx->supp_rates[0] =
           ((rate_mask & IWL_OFDM_RATES_MASK) >> IWL_FIRST_OFDM_RATE) & 0xFF;
 
        /* CCK */
-       cmd->cmd.tx.supp_rates[1] = (rate_mask & 0xF);
+       tx->supp_rates[1] = (rate_mask & 0xF);
 
        IWL_DEBUG_RATE("Tx sta id: %d, rate: %d (plcp), flags: 0x%4X "
                       "cck/ofdm mask: 0x%x/0x%x\n", sta_id,
-                      cmd->cmd.tx.rate, le32_to_cpu(cmd->cmd.tx.tx_flags),
-                      cmd->cmd.tx.supp_rates[1], cmd->cmd.tx.supp_rates[0]);
+                      tx->rate, le32_to_cpu(tx->tx_flags),
+                      tx->supp_rates[1], tx->supp_rates[0]);
 }
 
 u8 iwl3945_sync_sta(struct iwl_priv *priv, int sta_id, u16 tx_rate, u8 flags)
 
 #define SN_TO_SEQ(ssn) (((ssn) << 4) & IEEE80211_SCTL_SEQ)
 #define MAX_SN ((IEEE80211_SCTL_SEQ) >> 4)
 
-struct iwl3945_cmd;
-struct iwl_priv;
-
-struct iwl3945_cmd_meta {
-       struct iwl3945_cmd_meta *source;
-       union {
-               struct sk_buff *skb;
-               int (*callback)(struct iwl_priv *priv,
-                               struct iwl3945_cmd *cmd, struct sk_buff *skb);
-       } __attribute__ ((packed)) u;
-
-       /* The CMD_SIZE_HUGE flag bit indicates that the command
-        * structure is stored at the end of the shared queue memory. */
-       u32 flags;
-
-} __attribute__ ((packed));
-
-/**
- * struct iwl3945_cmd
- *
- * For allocation of the command and tx queues, this establishes the overall
- * size of the largest command we send to uCode, except for a scan command
- * (which is relatively huge; space is allocated separately).
- */
-struct iwl3945_cmd {
-       struct iwl3945_cmd_meta meta;
-       struct iwl_cmd_header hdr;
-       union {
-               struct iwl3945_addsta_cmd addsta;
-               struct iwl_led_cmd led;
-               u32 flags;
-               u8 val8;
-               u16 val16;
-               u32 val32;
-               struct iwl_bt_cmd bt;
-               struct iwl_rxon_time_cmd rxon_time;
-               struct iwl_powertable_cmd powertable;
-               struct iwl_qosparam_cmd qosparam;
-               struct iwl3945_tx_cmd tx;
-               struct iwl3945_tx_beacon_cmd tx_beacon;
-               struct iwl3945_rxon_assoc_cmd rxon_assoc;
-               u8 *indirect;
-               u8 payload[360];
-       } __attribute__ ((packed)) cmd;
-} __attribute__ ((packed));
-
-struct iwl3945_host_cmd {
-       u8 id;
-       u16 len;
-       struct iwl3945_cmd_meta meta;
-       const void *data;
-};
-
-#define TFD39_MAX_PAYLOAD_SIZE (sizeof(struct iwl3945_cmd) - \
-                             sizeof(struct iwl3945_cmd_meta))
-
 /*
  * RX related structures and functions
  */
 extern int iwl3945_send_cmd_pdu(struct iwl_priv *priv, u8 id, u16 len,
                            const void *data);
 extern int __must_check iwl3945_send_cmd(struct iwl_priv *priv,
-               struct iwl3945_host_cmd *cmd);
+                                        struct iwl_host_cmd *cmd);
 extern unsigned int iwl3945_fill_beacon_frame(struct iwl_priv *priv,
                                        struct ieee80211_hdr *hdr,int left);
 extern int iwl3945_rx_queue_update_write_ptr(struct iwl_priv *priv,
 extern unsigned int iwl3945_hw_get_beacon_cmd(struct iwl_priv *priv,
                                 struct iwl3945_frame *frame, u8 rate);
 extern int iwl3945_hw_get_rx_read(struct iwl_priv *priv);
-extern void iwl3945_hw_build_tx_cmd_rate(struct iwl_priv *priv,
-                                    struct iwl3945_cmd *cmd,
+void iwl3945_hw_build_tx_cmd_rate(struct iwl_priv *priv, struct iwl_cmd *cmd,
                                     struct ieee80211_tx_info *info,
                                     struct ieee80211_hdr *hdr,
                                     int sta_id, int tx_id);
 
         * For data Tx queues (all other queues), no super-size command
         * space is needed.
         */
-       len = sizeof(struct iwl3945_cmd) * slots_num;
+       len = sizeof(struct iwl_cmd) * slots_num;
        if (txq_id == IWL_CMD_QUEUE_NUM)
                len +=  IWL_MAX_SCAN_SIZE;
        txq->cmd = pci_alloc_consistent(dev, len, &txq->dma_addr_cmd);
             q->read_ptr = iwl_queue_inc_wrap(q->read_ptr, q->n_bd))
                iwl3945_hw_txq_free_tfd(priv, txq);
 
-       len = sizeof(struct iwl3945_cmd) * q->n_window;
+       len = sizeof(struct iwl_cmd) * q->n_window;
        if (q->id == IWL_CMD_QUEUE_NUM)
                len += IWL_MAX_SCAN_SIZE;
 
  * failed. On success, it turns the index (> 0) of command in the
  * command queue.
  */
-static int iwl3945_enqueue_hcmd(struct iwl_priv *priv, struct iwl3945_host_cmd *cmd)
+static int iwl3945_enqueue_hcmd(struct iwl_priv *priv, struct iwl_host_cmd *cmd)
 {
        struct iwl3945_tx_queue *txq = &priv->txq39[IWL_CMD_QUEUE_NUM];
        struct iwl_queue *q = &txq->q;
        struct iwl3945_tfd_frame *tfd;
        u32 *control_flags;
-       struct iwl3945_cmd *out_cmd;
+       struct iwl_cmd *out_cmd;
        u32 idx;
        u16 fix_size = (u16)(cmd->len + sizeof(out_cmd->hdr));
        dma_addr_t phys_addr;
        /* If any of the command structures end up being larger than
         * the TFD_MAX_PAYLOAD_SIZE, and it sent as a 'small' command then
         * we will need to increase the size of the TFD entries */
-       BUG_ON((fix_size > TFD39_MAX_PAYLOAD_SIZE) &&
+       BUG_ON((fix_size > TFD_MAX_PAYLOAD_SIZE) &&
               !(cmd->meta.flags & CMD_SIZE_HUGE));
 
 
                out_cmd->hdr.sequence |= SEQ_HUGE_FRAME;
 
        phys_addr = txq->dma_addr_cmd + sizeof(txq->cmd[0]) * idx +
-                       offsetof(struct iwl3945_cmd, hdr);
+                       offsetof(struct iwl_cmd, hdr);
        iwl3945_hw_txq_attach_buf_to_tfd(priv, tfd, phys_addr, fix_size);
 
        pad = U32_PAD(cmd->len);
        return ret ? ret : idx;
 }
 
-static int iwl3945_send_cmd_async(struct iwl_priv *priv, struct iwl3945_host_cmd *cmd)
+static int iwl3945_send_cmd_async(struct iwl_priv *priv,
+                                 struct iwl_host_cmd *cmd)
 {
        int ret;
 
        return 0;
 }
 
-static int iwl3945_send_cmd_sync(struct iwl_priv *priv, struct iwl3945_host_cmd *cmd)
+static int iwl3945_send_cmd_sync(struct iwl_priv *priv,
+                                struct iwl_host_cmd *cmd)
 {
        int cmd_idx;
        int ret;
 
 cancel:
        if (cmd->meta.flags & CMD_WANT_SKB) {
-               struct iwl3945_cmd *qcmd;
+               struct iwl_cmd *qcmd;
 
                /* Cancel the CMD_WANT_SKB flag for the cmd in the
                 * TX cmd queue. Otherwise in case the cmd comes
        return ret;
 }
 
-int iwl3945_send_cmd(struct iwl_priv *priv, struct iwl3945_host_cmd *cmd)
+int iwl3945_send_cmd(struct iwl_priv *priv, struct iwl_host_cmd *cmd)
 {
        if (cmd->meta.flags & CMD_ASYNC)
                return iwl3945_send_cmd_async(priv, cmd);
 
 int iwl3945_send_cmd_pdu(struct iwl_priv *priv, u8 id, u16 len, const void *data)
 {
-       struct iwl3945_host_cmd cmd = {
+       struct iwl_host_cmd cmd = {
                .id = id,
                .len = len,
                .data = data,
 
 static int __must_check iwl3945_send_cmd_u32(struct iwl_priv *priv, u8 id, u32 val)
 {
-       struct iwl3945_host_cmd cmd = {
+       struct iwl_host_cmd cmd = {
                .id = id,
                .len = sizeof(val),
                .data = &val,
        int rc = 0;
        struct iwl_rx_packet *res = NULL;
        struct iwl3945_rxon_assoc_cmd rxon_assoc;
-       struct iwl3945_host_cmd cmd = {
+       struct iwl_host_cmd cmd = {
                .id = REPLY_RXON_ASSOC,
                .len = sizeof(rxon_assoc),
                .meta.flags = CMD_WANT_SKB,
 {
        int rc = 0;
        struct iwl_rx_packet *res;
-       struct iwl3945_host_cmd cmd = {
+       struct iwl_host_cmd cmd = {
                .id = REPLY_SCAN_ABORT_CMD,
                .meta.flags = CMD_WANT_SKB,
        };
 }
 
 static int iwl3945_card_state_sync_callback(struct iwl_priv *priv,
-                                       struct iwl3945_cmd *cmd,
+                                       struct iwl_cmd *cmd,
                                        struct sk_buff *skb)
 {
        return 1;
  */
 static int iwl3945_send_card_state(struct iwl_priv *priv, u32 flags, u8 meta_flag)
 {
-       struct iwl3945_host_cmd cmd = {
+       struct iwl_host_cmd cmd = {
                .id = REPLY_CARD_STATE_CMD,
                .len = sizeof(u32),
                .data = &flags,
 }
 
 static int iwl3945_add_sta_sync_callback(struct iwl_priv *priv,
-                                    struct iwl3945_cmd *cmd, struct sk_buff *skb)
+                                    struct iwl_cmd *cmd, struct sk_buff *skb)
 {
        struct iwl_rx_packet *res = NULL;
 
 {
        struct iwl_rx_packet *res = NULL;
        int rc = 0;
-       struct iwl3945_host_cmd cmd = {
+       struct iwl_host_cmd cmd = {
                .id = REPLY_ADD_STA,
                .len = sizeof(struct iwl3945_addsta_cmd),
                .meta.flags = flags,
 
 static void iwl3945_build_tx_cmd_hwcrypto(struct iwl_priv *priv,
                                      struct ieee80211_tx_info *info,
-                                     struct iwl3945_cmd *cmd,
+                                     struct iwl_cmd *cmd,
                                      struct sk_buff *skb_frag,
                                      int last_frag)
 {
  * handle build REPLY_TX command notification.
  */
 static void iwl3945_build_tx_cmd_basic(struct iwl_priv *priv,
-                                 struct iwl3945_cmd *cmd,
+                                 struct iwl_cmd *cmd,
                                  struct ieee80211_tx_info *info,
                                  struct ieee80211_hdr *hdr,
                                  int is_unicast, u8 std_id)
        struct iwl_queue *q = NULL;
        dma_addr_t phys_addr;
        dma_addr_t txcmd_phys;
-       struct iwl3945_cmd *out_cmd = NULL;
+       struct iwl_cmd *out_cmd = NULL;
        u16 len, idx, len_org, hdr_len;
        u8 id;
        u8 unicast;
 
        /* Physical address of this Tx command's header (not MAC header!),
         * within command buffer array. */
-       txcmd_phys = txq->dma_addr_cmd + sizeof(struct iwl3945_cmd) * idx +
-                    offsetof(struct iwl3945_cmd, hdr);
+       txcmd_phys = txq->dma_addr_cmd + sizeof(struct iwl_cmd) * idx +
+                    offsetof(struct iwl_cmd, hdr);
 
        /* Add buffer containing Tx command and MAC(!) header to TFD's
         * first entry */
 {
        struct iwl_spectrum_cmd spectrum;
        struct iwl_rx_packet *res;
-       struct iwl3945_host_cmd cmd = {
+       struct iwl_host_cmd cmd = {
                .id = REPLY_SPECTRUM_MEASUREMENT_CMD,
                .data = (void *)&spectrum,
                .meta.flags = CMD_WANT_SKB,
        int index = SEQ_TO_INDEX(sequence);
        int huge =  !!(pkt->hdr.sequence & SEQ_HUGE_FRAME);
        int cmd_index;
-       struct iwl3945_cmd *cmd;
+       struct iwl_cmd *cmd;
 
        BUG_ON(txq_id != IWL_CMD_QUEUE_NUM);
 
 {
        struct iwl_priv *priv =
            container_of(data, struct iwl_priv, request_scan);
-       struct iwl3945_host_cmd cmd = {
+       struct iwl_host_cmd cmd = {
                .id = REPLY_SCAN_CMD,
                .len = sizeof(struct iwl3945_scan_cmd),
                .meta.flags = CMD_SIZE_HUGE,