drivers/staging/rtl8821ae/cam.c

   1 /******************************************************************************
   2  *
   3  * Copyright(c) 2009-2010  Realtek Corporation.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of version 2 of the GNU General Public License as
   7  * published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  12  * more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along with
  15  * this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
  17  *
  18  * The full GNU General Public License is included in this distribution in the
  19  * file called LICENSE.
  20  *
  21  * Contact Information:
  22  * wlanfae <wlanfae@realtek.com>
  23  * Realtek Corporation, No. 2, Innovation Road II, Hsinchu Science Park,
  24  * Hsinchu 300, Taiwan.
  25  *
  26  * Larry Finger <Larry.Finger@lwfinger.net>
  27  *
  28  *****************************************************************************/
  29 #include "wifi.h"
  30 #include "cam.h"
  31 #include <linux/export.h>
  32
  33 void rtl_cam_reset_sec_info(struct ieee80211_hw *hw)
  34 {
  35         struct rtl_priv *rtlpriv = rtl_priv(hw);
  36
  37         rtlpriv->sec.use_defaultkey = false;
  38         rtlpriv->sec.pairwise_enc_algorithm = NO_ENCRYPTION;
  39         rtlpriv->sec.group_enc_algorithm = NO_ENCRYPTION;
  40         memset(rtlpriv->sec.key_buf, 0, KEY_BUF_SIZE * MAX_KEY_LEN);
  41         memset(rtlpriv->sec.key_len, 0, KEY_BUF_SIZE);
  42         rtlpriv->sec.pairwise_key = NULL;
  43 }
  44
  45 static void rtl_cam_program_entry(struct ieee80211_hw *hw, u32 entry_no,
  46                            u8 *mac_addr, u8 *key_cont_128, u16 us_config)
  47 {
  48         struct rtl_priv *rtlpriv = rtl_priv(hw);
  49
  50         u32 target_command;
  51         u32 target_content = 0;
  52         u8 entry_i;
  53
  54         RT_PRINT_DATA(rtlpriv, COMP_SEC, DBG_DMESG, "Key content :",
  55                         key_cont_128, 16);
  56
  57         for (entry_i = 0; entry_i < CAM_CONTENT_COUNT; entry_i++) {
  58                 target_command = entry_i + CAM_CONTENT_COUNT * entry_no;
  59                 target_command = target_command | BIT(31) | BIT(16);
  60
  61                 if (entry_i == 0) {
  62                         target_content = (u32) (*(mac_addr + 0)) << 16 |
  63                             (u32) (*(mac_addr + 1)) << 24 | (u32) us_config;
  64
  65                         rtl_write_dword(rtlpriv, rtlpriv->cfg->maps[WCAMI],
  66                                         target_content);
  67                         rtl_write_dword(rtlpriv, rtlpriv->cfg->maps[RWCAM],
  68                                         target_command);
  69
  70                         RT_TRACE(COMP_SEC, DBG_LOUD,
  71                                  ("WRITE %x: %x \n",
  72                                   rtlpriv->cfg->maps[WCAMI], target_content));
  73                         RT_TRACE(COMP_SEC, DBG_LOUD,
  74                                  ("The Key ID is %d\n", entry_no));
  75                         RT_TRACE(COMP_SEC, DBG_LOUD,
  76                                  ("WRITE %x: %x \n",
  77                                   rtlpriv->cfg->maps[RWCAM], target_command));
  78
  79                 } else if (entry_i == 1) {
  80
  81                         target_content = (u32) (*(mac_addr + 5)) << 24 |
  82                             (u32) (*(mac_addr + 4)) << 16 |
  83                             (u32) (*(mac_addr + 3)) << 8 |
  84                             (u32) (*(mac_addr + 2));
  85
  86                         rtl_write_dword(rtlpriv, rtlpriv->cfg->maps[WCAMI],
  87                                         target_content);
  88                         rtl_write_dword(rtlpriv, rtlpriv->cfg->maps[RWCAM],
  89                                         target_command);
  90
  91                         RT_TRACE(COMP_SEC, DBG_LOUD,
  92                                  ("WRITE A4: %x \n", target_content));
  93                         RT_TRACE(COMP_SEC, DBG_LOUD,
  94                                  ("WRITE A0: %x \n", target_command));
  95
  96                 } else {
  97
  98                         target_content =
  99                             (u32) (*(key_cont_128 + (entry_i * 4 - 8) + 3)) <<
 100                             24 | (u32) (*(key_cont_128 + (entry_i * 4 - 8) + 2))
 101                             << 16 |
 102                             (u32) (*(key_cont_128 + (entry_i * 4 - 8) + 1)) << 8
 103                             | (u32) (*(key_cont_128 + (entry_i * 4 - 8) + 0));
 104
 105                         rtl_write_dword(rtlpriv, rtlpriv->cfg->maps[WCAMI],
 106                                         target_content);
 107                         rtl_write_dword(rtlpriv, rtlpriv->cfg->maps[RWCAM],
 108                                         target_command);
 109                         udelay(100);
 110
 111                         RT_TRACE(COMP_SEC, DBG_LOUD,
 112                                  ("WRITE A4: %x \n", target_content));
 113                         RT_TRACE(COMP_SEC, DBG_LOUD,
 114                                  ("WRITE A0: %x \n", target_command));
 115                 }
 116         }
 117
 118         RT_TRACE(COMP_SEC, DBG_LOUD,
 119                  ("after set key, usconfig:%x\n", us_config));
 120 }
 121
 122 u8 rtl_cam_add_one_entry(struct ieee80211_hw *hw, u8 *mac_addr,
 123                          u32 ul_key_id, u32 ul_entry_idx, u32 ul_enc_alg,
 124                          u32 ul_default_key, u8 *key_content)
 125 {
 126         u32 us_config;
 127         struct rtl_priv *rtlpriv = rtl_priv(hw);
 128
 129         RT_TRACE(COMP_SEC, DBG_DMESG,
 130                  ("EntryNo:%x, ulKeyId=%x, ulEncAlg=%x, "
 131                   "ulUseDK=%x MacAddr %pM\n",
 132                   ul_entry_idx, ul_key_id, ul_enc_alg,
 133                   ul_default_key, mac_addr));
 134
 135         if (ul_key_id == TOTAL_CAM_ENTRY) {
 136                 RT_TRACE(COMP_ERR, DBG_WARNING,
 137                          ("ulKeyId exceed!\n"));
 138                 return 0;
 139         }
 140
 141         if (ul_default_key == 1) {
 142                 us_config = CFG_VALID | ((u16) (ul_enc_alg) << 2);
 143         } else {
 144                 us_config = CFG_VALID | ((ul_enc_alg) << 2) | ul_key_id;
 145         }
 146
 147         rtl_cam_program_entry(hw, ul_entry_idx, mac_addr,
 148                               (u8 *) key_content, us_config);
 149
 150         RT_TRACE(COMP_SEC, DBG_DMESG, ("end \n"));
 151
 152         return 1;
 153
 154 }
 155
 156 int rtl_cam_delete_one_entry(struct ieee80211_hw *hw,
 157                              u8 *mac_addr, u32 ul_key_id)
 158 {
 159         u32 ul_command;
 160         struct rtl_priv *rtlpriv = rtl_priv(hw);
 161
 162         RT_TRACE(COMP_SEC, DBG_DMESG, ("key_idx:%d\n", ul_key_id));
 163
 164         ul_command = ul_key_id * CAM_CONTENT_COUNT;
 165         ul_command = ul_command | BIT(31) | BIT(16);
 166
 167         rtl_write_dword(rtlpriv, rtlpriv->cfg->maps[WCAMI], 0);
 168         rtl_write_dword(rtlpriv, rtlpriv->cfg->maps[RWCAM], ul_command);
 169
 170         RT_TRACE(COMP_SEC, DBG_DMESG,
 171                  ("rtl_cam_delete_one_entry(): WRITE A4: %x \n", 0));
 172         RT_TRACE(COMP_SEC, DBG_DMESG,
 173                  ("rtl_cam_delete_one_entry(): WRITE A0: %x \n", ul_command));
 174
 175         return 0;
 176
 177 }
 178
 179 void rtl_cam_reset_all_entry(struct ieee80211_hw *hw)
 180 {
 181         u32 ul_command;
 182         struct rtl_priv *rtlpriv = rtl_priv(hw);
 183
 184         ul_command = BIT(31) | BIT(30);
 185         rtl_write_dword(rtlpriv, rtlpriv->cfg->maps[RWCAM], ul_command);
 186 }
 187
 188 void rtl_cam_mark_invalid(struct ieee80211_hw *hw, u8 uc_index)
 189 {
 190         struct rtl_priv *rtlpriv = rtl_priv(hw);
 191
 192         u32 ul_command;
 193         u32 ul_content;
 194         u32 ul_enc_algo = rtlpriv->cfg->maps[SEC_CAM_AES];
 195
 196         switch (rtlpriv->sec.pairwise_enc_algorithm) {
 197         case WEP40_ENCRYPTION:
 198                 ul_enc_algo = rtlpriv->cfg->maps[SEC_CAM_WEP40];
 199                 break;
 200         case WEP104_ENCRYPTION:
 201                 ul_enc_algo = rtlpriv->cfg->maps[SEC_CAM_WEP104];
 202                 break;
 203         case TKIP_ENCRYPTION:
 204                 ul_enc_algo = rtlpriv->cfg->maps[SEC_CAM_TKIP];
 205                 break;
 206         case AESCCMP_ENCRYPTION:
 207                 ul_enc_algo = rtlpriv->cfg->maps[SEC_CAM_AES];
 208                 break;
 209         default:
 210                 ul_enc_algo = rtlpriv->cfg->maps[SEC_CAM_AES];
 211         }
 212
 213         ul_content = (uc_index & 3) | ((u16) (ul_enc_algo) << 2);
 214
 215         ul_content |= BIT(15);
 216         ul_command = CAM_CONTENT_COUNT * uc_index;
 217         ul_command = ul_command | BIT(31) | BIT(16);
 218
 219         rtl_write_dword(rtlpriv, rtlpriv->cfg->maps[WCAMI], ul_content);
 220         rtl_write_dword(rtlpriv, rtlpriv->cfg->maps[RWCAM], ul_command);
 221
 222         RT_TRACE(COMP_SEC, DBG_DMESG,
 223                  ("rtl_cam_mark_invalid(): WRITE A4: %x \n", ul_content));
 224         RT_TRACE(COMP_SEC, DBG_DMESG,
 225                  ("rtl_cam_mark_invalid(): WRITE A0: %x \n", ul_command));
 226 }
 227
 228 void rtl_cam_empty_entry(struct ieee80211_hw *hw, u8 uc_index)
 229 {
 230         struct rtl_priv *rtlpriv = rtl_priv(hw);
 231
 232         u32 ul_command;
 233         u32 ul_content;
 234         u32 ul_encalgo = rtlpriv->cfg->maps[SEC_CAM_AES];
 235         u8 entry_i;
 236
 237         switch (rtlpriv->sec.pairwise_enc_algorithm) {
 238         case WEP40_ENCRYPTION:
 239                 ul_encalgo = rtlpriv->cfg->maps[SEC_CAM_WEP40];
 240                 break;
 241         case WEP104_ENCRYPTION:
 242                 ul_encalgo = rtlpriv->cfg->maps[SEC_CAM_WEP104];
 243                 break;
 244         case TKIP_ENCRYPTION:
 245                 ul_encalgo = rtlpriv->cfg->maps[SEC_CAM_TKIP];
 246                 break;
 247         case AESCCMP_ENCRYPTION:
 248                 ul_encalgo = rtlpriv->cfg->maps[SEC_CAM_AES];
 249                 break;
 250         default:
 251                 ul_encalgo = rtlpriv->cfg->maps[SEC_CAM_AES];
 252         }
 253
 254         for (entry_i = 0; entry_i < CAM_CONTENT_COUNT; entry_i++) {
 255
 256                 if (entry_i == 0) {
 257                         ul_content =
 258                             (uc_index & 0x03) | ((u16) (ul_encalgo) << 2);
 259                         ul_content |= BIT(15);
 260
 261                 } else {
 262                         ul_content = 0;
 263                 }
 264
 265                 ul_command = CAM_CONTENT_COUNT * uc_index + entry_i;
 266                 ul_command = ul_command | BIT(31) | BIT(16);
 267
 268                 rtl_write_dword(rtlpriv, rtlpriv->cfg->maps[WCAMI], ul_content);
 269                 rtl_write_dword(rtlpriv, rtlpriv->cfg->maps[RWCAM], ul_command);
 270
 271                 RT_TRACE(COMP_SEC, DBG_LOUD,
 272                          ("rtl_cam_empty_entry(): WRITE A4: %x \n",
 273                           ul_content));
 274                 RT_TRACE(COMP_SEC, DBG_LOUD,
 275                          ("rtl_cam_empty_entry(): WRITE A0: %x \n",
 276                           ul_command));
 277         }
 278
 279 }
 280
 281 u8 rtl_cam_get_free_entry(struct ieee80211_hw *hw, u8 *sta_addr)
 282 {
 283         struct rtl_priv *rtlpriv = rtl_priv(hw);
 284         u32 bitmap = (rtlpriv->sec.hwsec_cam_bitmap) >> 4;
 285         u8 entry_idx = 0;
 286         u8 i, *addr;
 287
 288         if (NULL == sta_addr) {
 289                 RT_TRACE(COMP_SEC, DBG_EMERG,
 290                         ("sta_addr is NULL.\n"));
 291                 return TOTAL_CAM_ENTRY;
 292         }
 293         /* Does STA already exist? */
 294         for (i = 4; i < TOTAL_CAM_ENTRY; i++) {
 295                 addr = rtlpriv->sec.hwsec_cam_sta_addr[i];
 296                 if(memcmp(addr, sta_addr, ETH_ALEN) == 0)
 297                         return i;
 298         }
 299         /* Get a free CAM entry. */
 300         for (entry_idx = 4; entry_idx < TOTAL_CAM_ENTRY; entry_idx++) {
 301                 if ((bitmap & BIT(0)) == 0) {
 302                         RT_TRACE(COMP_SEC, DBG_EMERG,
 303                                 ("-----hwsec_cam_bitmap: 0x%x entry_idx=%d\n",
 304                                  rtlpriv->sec.hwsec_cam_bitmap, entry_idx));
 305                         rtlpriv->sec.hwsec_cam_bitmap |= BIT(0) << entry_idx;
 306                         memcpy(rtlpriv->sec.hwsec_cam_sta_addr[entry_idx],
 307                                sta_addr, ETH_ALEN);
 308                         return entry_idx;
 309                 }
 310                 bitmap = bitmap >>1;
 311         }
 312         return TOTAL_CAM_ENTRY;
 313 }
 314
 315 void rtl_cam_del_entry(struct ieee80211_hw *hw, u8 *sta_addr)
 316 {
 317         struct rtl_priv *rtlpriv = rtl_priv(hw);
 318         u32 bitmap;
 319         u8 i, *addr;
 320
 321         if (NULL == sta_addr) {
 322                 RT_TRACE(COMP_SEC, DBG_EMERG,
 323                         ("sta_addr is NULL.\n"));
 324         }
 325
 326         if ((sta_addr[0]|sta_addr[1]|sta_addr[2]|sta_addr[3]|\
 327                                 sta_addr[4]|sta_addr[5]) == 0) {
 328                 RT_TRACE(COMP_SEC, DBG_EMERG,
 329                         ("sta_addr is 00:00:00:00:00:00.\n"));
 330                 return;
 331         }
 332         /* Does STA already exist? */
 333         for (i = 4; i < TOTAL_CAM_ENTRY; i++) {
 334                 addr = rtlpriv->sec.hwsec_cam_sta_addr[i];
 335                 bitmap = (rtlpriv->sec.hwsec_cam_bitmap) >> i;
 336                 if (((bitmap & BIT(0)) == BIT(0)) &&
 337                     (memcmp(addr, sta_addr, ETH_ALEN) == 0)) {
 338                         /* Remove from HW Security CAM */
 339                         memset(rtlpriv->sec.hwsec_cam_sta_addr[i], 0, ETH_ALEN);
 340                         rtlpriv->sec.hwsec_cam_bitmap &= ~(BIT(0) << i);
 341                         printk("&&&&&&&&&del entry %d\n",i);
 342                 }
 343         }
 344         return;
 345 }