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  * You should have received a copy of the GNU General Public License along with
  10  * this program; if not, write to the Free Software Foundation, Inc.,
  11  * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
  12  *
  13  * The full GNU General Public License is included in this distribution in the
  14  * file called LICENSE.
  15  *
  16  * Contact Information:
  17  * wlanfae <wlanfae@realtek.com>
  18 ******************************************************************************/
  19
  20 #include "rtl_core.h"
  21 #include "r8192E_hw.h"
  22 #include "r8192E_hwimg.h"
  23 #include "r8192E_firmware.h"
  24 #include <linux/firmware.h>
  25
  26 void firmware_init_param(struct net_device *dev)
  27 {
  28         struct r8192_priv *priv = rtllib_priv(dev);
  29         struct rt_firmware *pfirmware = priv->pFirmware;
  30
  31         pfirmware->cmdpacket_frag_thresold = GET_COMMAND_PACKET_FRAG_THRESHOLD(
  32                                              MAX_TRANSMIT_BUFFER_SIZE);
  33 }
  34
  35 static bool fw_download_code(struct net_device *dev, u8 *code_virtual_address,
  36                              u32 buffer_len)
  37 {
  38         struct r8192_priv *priv = rtllib_priv(dev);
  39         bool                rt_status = true;
  40         u16                 frag_threshold;
  41         u16                 frag_length, frag_offset = 0;
  42         int                 i;
  43
  44         struct rt_firmware *pfirmware = priv->pFirmware;
  45         struct sk_buff      *skb;
  46         unsigned char       *seg_ptr;
  47         struct cb_desc *tcb_desc;
  48         u8                  bLastIniPkt;
  49
  50         firmware_init_param(dev);
  51         frag_threshold = pfirmware->cmdpacket_frag_thresold;
  52         do {
  53                 if ((buffer_len - frag_offset) > frag_threshold) {
  54                         frag_length = frag_threshold ;
  55                         bLastIniPkt = 0;
  56
  57                 } else {
  58                         frag_length = buffer_len - frag_offset;
  59                         bLastIniPkt = 1;
  60
  61                 }
  62
  63                 skb  = dev_alloc_skb(frag_length + 4);
  64                 memcpy((unsigned char *)(skb->cb), &dev, sizeof(dev));
  65                 tcb_desc = (struct cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
  66                 tcb_desc->queue_index = TXCMD_QUEUE;
  67                 tcb_desc->bCmdOrInit = DESC_PACKET_TYPE_INIT;
  68                 tcb_desc->bLastIniPkt = bLastIniPkt;
  69
  70                 seg_ptr = skb->data;
  71                 for (i = 0; i < frag_length; i += 4) {
  72                         *seg_ptr++ = ((i+0) < frag_length) ?
  73                                      code_virtual_address[i+3] : 0;
  74                         *seg_ptr++ = ((i+1) < frag_length) ?
  75                                      code_virtual_address[i+2] : 0;
  76                         *seg_ptr++ = ((i+2) < frag_length) ?
  77                                      code_virtual_address[i+1] : 0;
  78                         *seg_ptr++ = ((i+3) < frag_length) ?
  79                                      code_virtual_address[i+0] : 0;
  80                 }
  81                 tcb_desc->txbuf_size = (u16)i;
  82                 skb_put(skb, i);
  83
  84                 if (!priv->rtllib->check_nic_enough_desc(dev, tcb_desc->queue_index) ||
  85                     (!skb_queue_empty(&priv->rtllib->skb_waitQ[tcb_desc->queue_index])) ||
  86                     (priv->rtllib->queue_stop)) {
  87                         RT_TRACE(COMP_FIRMWARE, "===================> tx "
  88                                  "full!\n");
  89                         skb_queue_tail(&priv->rtllib->skb_waitQ
  90                                         [tcb_desc->queue_index], skb);
  91                 } else {
  92                 priv->rtllib->softmac_hard_start_xmit(skb, dev);
  93                 }
  94
  95                 code_virtual_address += frag_length;
  96                 frag_offset += frag_length;
  97
  98         } while (frag_offset < buffer_len);
  99
 100         write_nic_byte(dev, TPPoll, TPPoll_CQ);
 101
 102         return rt_status;
 103 }
 104
 105 static bool CPUcheck_maincodeok_turnonCPU(struct net_device *dev)
 106 {
 107         bool            rt_status = true;
 108         u32             CPU_status = 0;
 109         unsigned long   timeout;
 110
 111         timeout = jiffies + MSECS(200);
 112         while (time_before(jiffies, timeout)) {
 113                 CPU_status = read_nic_dword(dev, CPU_GEN);
 114                 if (CPU_status & CPU_GEN_PUT_CODE_OK)
 115                         break;
 116                 mdelay(2);
 117         }
 118
 119         if (!(CPU_status&CPU_GEN_PUT_CODE_OK)) {
 120                 RT_TRACE(COMP_ERR, "Download Firmware: Put code fail!\n");
 121                 goto CPUCheckMainCodeOKAndTurnOnCPU_Fail;
 122         } else {
 123                 RT_TRACE(COMP_FIRMWARE, "Download Firmware: Put code ok!\n");
 124         }
 125
 126         CPU_status = read_nic_dword(dev, CPU_GEN);
 127         write_nic_byte(dev, CPU_GEN,
 128                        (u8)((CPU_status|CPU_GEN_PWR_STB_CPU)&0xff));
 129         mdelay(1);
 130
 131         timeout = jiffies + MSECS(200);
 132         while (time_before(jiffies, timeout)) {
 133                 CPU_status = read_nic_dword(dev, CPU_GEN);
 134                 if (CPU_status&CPU_GEN_BOOT_RDY)
 135                         break;
 136                 mdelay(2);
 137         }
 138
 139         if (!(CPU_status&CPU_GEN_BOOT_RDY))
 140                 goto CPUCheckMainCodeOKAndTurnOnCPU_Fail;
 141         else
 142                 RT_TRACE(COMP_FIRMWARE, "Download Firmware: Boot ready!\n");
 143
 144         return rt_status;
 145
 146 CPUCheckMainCodeOKAndTurnOnCPU_Fail:
 147         RT_TRACE(COMP_ERR, "ERR in %s()\n", __func__);
 148         rt_status = false;
 149         return rt_status;
 150 }
 151
 152 static bool CPUcheck_firmware_ready(struct net_device *dev)
 153 {
 154
 155         bool    rt_status = true;
 156         u32     CPU_status = 0;
 157         unsigned long timeout;
 158
 159         timeout = jiffies + MSECS(20);
 160         while (time_before(jiffies, timeout)) {
 161                 CPU_status = read_nic_dword(dev, CPU_GEN);
 162                 if (CPU_status&CPU_GEN_FIRM_RDY)
 163                         break;
 164                 mdelay(2);
 165         }
 166
 167         if (!(CPU_status&CPU_GEN_FIRM_RDY))
 168                 goto CPUCheckFirmwareReady_Fail;
 169         else
 170                 RT_TRACE(COMP_FIRMWARE, "Download Firmware: Firmware ready!\n");
 171
 172         return rt_status;
 173
 174 CPUCheckFirmwareReady_Fail:
 175         RT_TRACE(COMP_ERR, "ERR in %s()\n", __func__);
 176         rt_status = false;
 177         return rt_status;
 178
 179 }
 180
 181 static bool firmware_check_ready(struct net_device *dev,
 182                                         u8 load_fw_status)
 183 {
 184         struct r8192_priv *priv = rtllib_priv(dev);
 185         struct rt_firmware *pfirmware = priv->pFirmware;
 186         bool rt_status  = true;
 187
 188         switch (load_fw_status) {
 189         case FW_INIT_STEP0_BOOT:
 190                 pfirmware->firmware_status = FW_STATUS_1_MOVE_BOOT_CODE;
 191                 break;
 192
 193         case FW_INIT_STEP1_MAIN:
 194                 pfirmware->firmware_status = FW_STATUS_2_MOVE_MAIN_CODE;
 195
 196                 rt_status = CPUcheck_maincodeok_turnonCPU(dev);
 197                 if (rt_status)
 198                         pfirmware->firmware_status = FW_STATUS_3_TURNON_CPU;
 199                 else
 200                         RT_TRACE(COMP_FIRMWARE, "CPUcheck_maincodeok_turnon"
 201                                  "CPU fail!\n");
 202
 203                 break;
 204
 205         case FW_INIT_STEP2_DATA:
 206                 pfirmware->firmware_status = FW_STATUS_4_MOVE_DATA_CODE;
 207                 mdelay(1);
 208
 209                 rt_status = CPUcheck_firmware_ready(dev);
 210                 if (rt_status)
 211                         pfirmware->firmware_status = FW_STATUS_5_READY;
 212                 else
 213                         RT_TRACE(COMP_FIRMWARE, "CPUcheck_firmware_ready fail"
 214                                  "(%d)!\n", rt_status);
 215
 216                 break;
 217         default:
 218                 rt_status = false;
 219                 RT_TRACE(COMP_FIRMWARE, "Unknown firmware status");
 220                 break;
 221         }
 222
 223         return rt_status;
 224 }
 225
 226 bool init_firmware(struct net_device *dev)
 227 {
 228         struct r8192_priv *priv = rtllib_priv(dev);
 229         bool                    rt_status = true;
 230
 231         u8      *firmware_img_buf[3] = { /*(DEBLOBBED)*/};
 232
 233         u32     firmware_img_len[3] = { /*(DEBLOBBED)*/};
 234         u32     file_length = 0;
 235         u8      *mapped_file = NULL;
 236         u8      init_step = 0;
 237         enum opt_rst_type rst_opt = OPT_SYSTEM_RESET;
 238         enum firmware_init_step starting_state = FW_INIT_STEP0_BOOT;
 239
 240         struct rt_firmware *pfirmware = priv->pFirmware;
 241
 242         RT_TRACE(COMP_FIRMWARE, " PlatformInitFirmware()==>\n");
 243
 244         if (pfirmware->firmware_status == FW_STATUS_0_INIT) {
 245                 rst_opt = OPT_SYSTEM_RESET;
 246                 starting_state = FW_INIT_STEP0_BOOT;
 247
 248         } else if (pfirmware->firmware_status == FW_STATUS_5_READY) {
 249                 rst_opt = OPT_FIRMWARE_RESET;
 250                 starting_state = FW_INIT_STEP2_DATA;
 251         } else {
 252                 RT_TRACE(COMP_FIRMWARE, "PlatformInitFirmware: undefined"
 253                          " firmware state\n");
 254         }
 255
 256         priv->firmware_source = FW_SOURCE_IMG_FILE;
 257         for (init_step = starting_state; init_step <= FW_INIT_STEP2_DATA;
 258              init_step++) {
 259                 if (rst_opt == OPT_SYSTEM_RESET) {
 260                         switch (priv->firmware_source) {
 261                         case FW_SOURCE_IMG_FILE:
 262                         {
 263                                 if (pfirmware->firmware_buf_size[init_step] == 0) {
 264                                         const char *fw_name[3] = {
 265                                                         RTL8192E_BOOT_IMG_FW,
 266                                                         RTL8192E_MAIN_IMG_FW,
 267                                                         RTL8192E_DATA_IMG_FW
 268                                         };
 269                                         const struct firmware   *fw_entry;
 270                                         int rc;
 271                                         rc = reject_firmware(&fw_entry,
 272                                          fw_name[init_step], &priv->pdev->dev);
 273                                         if (rc < 0) {
 274                                                 RT_TRACE(COMP_FIRMWARE, "request firm"
 275                                                  "ware fail!\n");
 276                                                 goto download_firmware_fail;
 277                                         }
 278                                         if (fw_entry->size >
 279                                     sizeof(pfirmware->firmware_buf[init_step])) {
 280                                                 RT_TRACE(COMP_FIRMWARE, "img file size "
 281                                                  "exceed the container struct "
 282                                                  "buffer fail!\n");
 283                                                 goto download_firmware_fail;
 284                                         }
 285
 286                                         if (init_step != FW_INIT_STEP1_MAIN) {
 287                                                 memcpy(pfirmware->firmware_buf[init_step],
 288                                                fw_entry->data, fw_entry->size);
 289                                                 pfirmware->firmware_buf_size[init_step] =
 290                                                fw_entry->size;
 291
 292                                         } else {
 293                                                 memset(pfirmware->firmware_buf[init_step],
 294                                                0, 128);
 295                                                 memcpy(&pfirmware->firmware_buf[init_step][128],
 296                                                fw_entry->data, fw_entry->size);
 297                                                 pfirmware->firmware_buf_size[init_step] =
 298                                                          fw_entry->size + 128;
 299                                         }
 300
 301                                         if (rst_opt == OPT_SYSTEM_RESET)
 302                                                 release_firmware(fw_entry);
 303                                 }
 304                                 mapped_file = pfirmware->firmware_buf[init_step];
 305                                 file_length = pfirmware->firmware_buf_size[init_step];
 306                                 break;
 307                         }
 308                         case FW_SOURCE_HEADER_FILE:
 309                                 mapped_file =  firmware_img_buf[init_step];
 310                                 file_length  = firmware_img_len[init_step];
 311                                 if (init_step == FW_INIT_STEP2_DATA) {
 312                                         memcpy(pfirmware->firmware_buf[init_step], mapped_file, file_length);
 313                                         pfirmware->firmware_buf_size[init_step] = file_length;
 314                                 }
 315                                 break;
 316
 317                         default:
 318                                 break;
 319                         }
 320
 321
 322                 } else if (rst_opt == OPT_FIRMWARE_RESET) {
 323                         mapped_file = pfirmware->firmware_buf[init_step];
 324                         file_length = pfirmware->firmware_buf_size[init_step];
 325                 }
 326
 327                 rt_status = fw_download_code(dev, mapped_file, file_length);
 328                 if (rt_status != true) {
 329                         goto download_firmware_fail;
 330                 }
 331
 332                 if (!firmware_check_ready(dev, init_step)) {
 333                         goto download_firmware_fail;
 334                 }
 335         }
 336
 337         RT_TRACE(COMP_FIRMWARE, "Firmware Download Success\n");
 338         return rt_status;
 339
 340 download_firmware_fail:
 341         RT_TRACE(COMP_ERR, "ERR in %s()\n", __func__);
 342         rt_status = false;
 343         return rt_status;
 344
 345 }