drivers/staging/rtl8192e/rtl8192e/r8192E_firmware.c

   1 /******************************************************************************
   2  * Copyright(c) 2008 - 2010 Realtek Corporation. All rights reserved.
   3  *
   4  * This program is distributed in the hope that it will be useful, but WITHOUT
   5  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   6  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
   7  * more details.
   8  *
   9  * The full GNU General Public License is included in this distribution in the
  10  * file called LICENSE.
  11  *
  12  * Contact Information:
  13  * wlanfae <wlanfae@realtek.com>
  14 ******************************************************************************/
  15
  16 #include "rtl_core.h"
  17 #include "r8192E_hw.h"
  18 #include "r8192E_hwimg.h"
  19 #include "r8192E_firmware.h"
  20 #include <linux/firmware.h>
  21
  22 static bool _rtl92e_wait_for_fw(struct net_device *dev, u32 mask, u32 timeout)
  23 {
  24         unsigned long deadline = jiffies + msecs_to_jiffies(timeout);
  25
  26         while (time_before(jiffies, deadline)) {
  27                 if (rtl92e_readl(dev, CPU_GEN) & mask)
  28                         return true;
  29                 mdelay(2);
  30         }
  31         return false;
  32 }
  33
  34 static bool _rtl92e_fw_download_code(struct net_device *dev,
  35                                      u8 *code_virtual_address, u32 buffer_len)
  36 {
  37         struct r8192_priv *priv = rtllib_priv(dev);
  38         u16                 frag_length, frag_offset = 0;
  39         struct sk_buff      *skb;
  40         struct cb_desc *tcb_desc;
  41         u8                  bLastIniPkt;
  42
  43         do {
  44                 if ((buffer_len - frag_offset) > CMDPACKET_FRAG_SIZE) {
  45                         frag_length = CMDPACKET_FRAG_SIZE;
  46                         bLastIniPkt = 0;
  47
  48                 } else {
  49                         frag_length = buffer_len - frag_offset;
  50                         bLastIniPkt = 1;
  51
  52                 }
  53
  54                 skb  = dev_alloc_skb(frag_length + 4);
  55                 memcpy((unsigned char *)(skb->cb), &dev, sizeof(dev));
  56                 tcb_desc = (struct cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
  57                 tcb_desc->queue_index = TXCMD_QUEUE;
  58                 tcb_desc->bCmdOrInit = DESC_PACKET_TYPE_INIT;
  59                 tcb_desc->bLastIniPkt = bLastIniPkt;
  60                 tcb_desc->txbuf_size = (u16)frag_length;
  61                 memcpy(skb->data, code_virtual_address, frag_length);
  62                 skb_put(skb, frag_length);
  63
  64                 if (!priv->rtllib->check_nic_enough_desc(dev, tcb_desc->queue_index) ||
  65                     (!skb_queue_empty(&priv->rtllib->skb_waitQ[tcb_desc->queue_index])) ||
  66                     (priv->rtllib->queue_stop)) {
  67                         RT_TRACE(COMP_FIRMWARE,
  68                                  "===================> tx full!\n");
  69                         skb_queue_tail(&priv->rtllib->skb_waitQ
  70                                         [tcb_desc->queue_index], skb);
  71                 } else {
  72                 priv->rtllib->softmac_hard_start_xmit(skb, dev);
  73                 }
  74
  75                 code_virtual_address += frag_length;
  76                 frag_offset += frag_length;
  77
  78         } while (frag_offset < buffer_len);
  79
  80         rtl92e_writeb(dev, TPPoll, TPPoll_CQ);
  81
  82         return true;
  83 }
  84
  85 static bool _rtl92e_fw_boot_cpu(struct net_device *dev)
  86 {
  87         u32             CPU_status = 0;
  88
  89         if (!_rtl92e_wait_for_fw(dev, CPU_GEN_PUT_CODE_OK, 200)) {
  90                 netdev_err(dev, "Firmware download failed.\n");
  91                 goto CPUCheckMainCodeOKAndTurnOnCPU_Fail;
  92         }
  93         RT_TRACE(COMP_FIRMWARE, "Download Firmware: Put code ok!\n");
  94
  95         CPU_status = rtl92e_readl(dev, CPU_GEN);
  96         rtl92e_writeb(dev, CPU_GEN,
  97                       (u8)((CPU_status|CPU_GEN_PWR_STB_CPU)&0xff));
  98         mdelay(1);
  99
 100         if (!_rtl92e_wait_for_fw(dev, CPU_GEN_BOOT_RDY, 200)) {
 101                 netdev_err(dev, "Firmware boot failed.\n");
 102                 goto CPUCheckMainCodeOKAndTurnOnCPU_Fail;
 103         }
 104
 105         RT_TRACE(COMP_FIRMWARE, "Download Firmware: Boot ready!\n");
 106
 107         return true;
 108
 109 CPUCheckMainCodeOKAndTurnOnCPU_Fail:
 110         return false;
 111 }
 112
 113 static bool _rtl92e_fw_check_ready(struct net_device *dev,
 114                                    u8 load_fw_status)
 115 {
 116         struct r8192_priv *priv = rtllib_priv(dev);
 117         struct rt_firmware *pfirmware = priv->pFirmware;
 118         bool rt_status  = true;
 119
 120         switch (load_fw_status) {
 121         case FW_INIT_STEP0_BOOT:
 122                 pfirmware->status = FW_STATUS_1_MOVE_BOOT_CODE;
 123                 break;
 124
 125         case FW_INIT_STEP1_MAIN:
 126                 pfirmware->status = FW_STATUS_2_MOVE_MAIN_CODE;
 127
 128                 rt_status = _rtl92e_fw_boot_cpu(dev);
 129                 if (rt_status)
 130                         pfirmware->status = FW_STATUS_3_TURNON_CPU;
 131                 else
 132                         RT_TRACE(COMP_FIRMWARE, "_rtl92e_fw_boot_cpu fail!\n");
 133
 134                 break;
 135
 136         case FW_INIT_STEP2_DATA:
 137                 pfirmware->status = FW_STATUS_4_MOVE_DATA_CODE;
 138                 mdelay(1);
 139
 140                 rt_status = _rtl92e_wait_for_fw(dev, CPU_GEN_FIRM_RDY, 20);
 141                 if (rt_status)
 142                         pfirmware->status = FW_STATUS_5_READY;
 143                 else
 144                         RT_TRACE(COMP_FIRMWARE,
 145                                  "_rtl92e_is_fw_ready fail(%d)!\n",
 146                                  rt_status);
 147                 break;
 148         default:
 149                 rt_status = false;
 150                 RT_TRACE(COMP_FIRMWARE, "Unknown firmware status");
 151                 break;
 152         }
 153
 154         return rt_status;
 155 }
 156
 157 static bool _rtl92e_fw_prepare(struct net_device *dev, struct rt_fw_blob *blob,
 158                                const char *name, u8 padding)
 159 {
 160         const struct firmware *fw;
 161         int rc, i;
 162         bool ret = true;
 163
 164         rc = request_firmware(&fw, name, &dev->dev);
 165         if (rc < 0)
 166                 return false;
 167
 168         if (round_up(fw->size, 4) > MAX_FW_SIZE - padding) {
 169                 netdev_err(dev, "Firmware image %s too big for the device.\n",
 170                            name);
 171                 ret = false;
 172                 goto out;
 173         }
 174
 175         if (padding)
 176                 memset(blob->data, 0, padding);
 177         if (fw->size % 4)
 178                 memset(blob->data + padding + fw->size, 0, 4);
 179         memcpy(blob->data + padding, fw->data, fw->size);
 180
 181         blob->size = round_up(fw->size, 4) + padding;
 182
 183         /* Swap endian - firmware is packaged in invalid endiannes*/
 184         for (i = padding; i < blob->size; i += 4) {
 185                 u32 *data = (u32 *)(blob->data + i);
 186                 *data = swab32p(data);
 187         }
 188 out:
 189         release_firmware(fw);
 190         return ret;
 191 }
 192
 193 bool rtl92e_init_fw(struct net_device *dev)
 194 {
 195         struct r8192_priv *priv = rtllib_priv(dev);
 196         bool                    rt_status = true;
 197
 198         u32     file_length = 0;
 199         u8      *mapped_file = NULL;
 200         u8      i = 0;
 201         enum opt_rst_type rst_opt = OPT_SYSTEM_RESET;
 202         enum firmware_init_step starting_state = FW_INIT_STEP0_BOOT;
 203
 204         struct rt_firmware *pfirmware = priv->pFirmware;
 205
 206         RT_TRACE(COMP_FIRMWARE, " PlatformInitFirmware()==>\n");
 207
 208         if (pfirmware->status == FW_STATUS_0_INIT) {
 209                 rst_opt = OPT_SYSTEM_RESET;
 210                 starting_state = FW_INIT_STEP0_BOOT;
 211
 212         } else if (pfirmware->status == FW_STATUS_5_READY) {
 213                 rst_opt = OPT_FIRMWARE_RESET;
 214                 starting_state = FW_INIT_STEP2_DATA;
 215         } else {
 216                 RT_TRACE(COMP_FIRMWARE,
 217                          "PlatformInitFirmware: undefined firmware state\n");
 218         }
 219
 220         for (i = starting_state; i <= FW_INIT_STEP2_DATA; i++) {
 221                 if (rst_opt == OPT_SYSTEM_RESET) {
 222                         if (pfirmware->blobs[i].size == 0) {
 223                                 const char *fw_name[3] = {
 224                                         RTL8192E_BOOT_IMG_FW,
 225                                         RTL8192E_MAIN_IMG_FW,
 226                                         RTL8192E_DATA_IMG_FW
 227                                 };
 228                                 int pad = 0;
 229
 230                                 if (i == FW_INIT_STEP1_MAIN)
 231                                         pad = 128;
 232
 233                                 if (!_rtl92e_fw_prepare(dev,
 234                                                         &pfirmware->blobs[i],
 235                                                         fw_name[i],
 236                                                         pad))
 237                                         goto download_firmware_fail;
 238                         }
 239                 }
 240
 241                 mapped_file = pfirmware->blobs[i].data;
 242                 file_length = pfirmware->blobs[i].size;
 243
 244                 rt_status = _rtl92e_fw_download_code(dev, mapped_file,
 245                                                      file_length);
 246                 if (!rt_status)
 247                         goto download_firmware_fail;
 248
 249                 if (!_rtl92e_fw_check_ready(dev, i))
 250                         goto download_firmware_fail;
 251         }
 252
 253         RT_TRACE(COMP_FIRMWARE, "Firmware Download Success\n");
 254         return rt_status;
 255
 256 download_firmware_fail:
 257         netdev_err(dev, "%s: Failed to initialize firmware.\n", __func__);
 258         rt_status = false;
 259         return rt_status;
 260
 261 }