Branch data     Line data    Source code

       1                 :            : // SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
       2                 :            : /* Copyright(c) 2018-2019  Realtek Corporation
       3                 :            :  */
       4                 :            : 
       5                 :            : #include "main.h"
       6                 :            : #include "sec.h"
       7                 :            : #include "reg.h"
       8                 :            : 
       9                 :          0 : int rtw_sec_get_free_cam(struct rtw_sec_desc *sec)
      10                 :            : {
      11                 :            :         /* if default key search is enabled, the first 4 cam entries
      12                 :            :          * are used to direct map to group key with its key->key_idx, so
      13                 :            :          * driver should use cam entries after 4 to install pairwise key
      14                 :            :          */
      15         [ #  # ]:          0 :         if (sec->default_key_search)
      16                 :          0 :                 return find_next_zero_bit(sec->cam_map, RTW_MAX_SEC_CAM_NUM,
      17                 :            :                                           RTW_SEC_DEFAULT_KEY_NUM);
      18                 :            : 
      19                 :          0 :         return find_first_zero_bit(sec->cam_map, RTW_MAX_SEC_CAM_NUM);
      20                 :            : }
      21                 :            : 
      22                 :          0 : void rtw_sec_write_cam(struct rtw_dev *rtwdev,
      23                 :            :                        struct rtw_sec_desc *sec,
      24                 :            :                        struct ieee80211_sta *sta,
      25                 :            :                        struct ieee80211_key_conf *key,
      26                 :            :                        u8 hw_key_type, u8 hw_key_idx)
      27                 :            : {
      28                 :          0 :         struct rtw_cam_entry *cam = &sec->cam_table[hw_key_idx];
      29                 :          0 :         u32 write_cmd;
      30                 :          0 :         u32 command;
      31                 :          0 :         u32 content;
      32                 :          0 :         u32 addr;
      33                 :          0 :         int i, j;
      34                 :            : 
      35                 :          0 :         set_bit(hw_key_idx, sec->cam_map);
      36                 :          0 :         cam->valid = true;
      37                 :          0 :         cam->group = !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE);
      38                 :          0 :         cam->hw_key_type = hw_key_type;
      39                 :          0 :         cam->key = key;
      40         [ #  # ]:          0 :         if (sta)
      41                 :          0 :                 ether_addr_copy(cam->addr, sta->addr);
      42                 :            :         else
      43                 :          0 :                 eth_broadcast_addr(cam->addr);
      44                 :            : 
      45                 :          0 :         write_cmd = RTW_SEC_CMD_WRITE_ENABLE | RTW_SEC_CMD_POLLING;
      46                 :          0 :         addr = hw_key_idx << RTW_SEC_CAM_ENTRY_SHIFT;
      47         [ #  # ]:          0 :         for (i = 5; i >= 0; i--) {
      48      [ #  #  # ]:          0 :                 switch (i) {
      49                 :          0 :                 case 0:
      50                 :          0 :                         content = ((key->keyidx & 0x3))          |
      51                 :          0 :                                   ((hw_key_type & 0x7)      << 2)     |
      52                 :          0 :                                   (cam->group                << 6)     |
      53                 :          0 :                                   (cam->valid                << 15)    |
      54                 :          0 :                                   (cam->addr[0]              << 16)    |
      55                 :          0 :                                   (cam->addr[1]              << 24);
      56                 :          0 :                         break;
      57                 :          0 :                 case 1:
      58                 :          0 :                         content = (cam->addr[2])             |
      59                 :          0 :                                   (cam->addr[3]              << 8)     |
      60                 :          0 :                                   (cam->addr[4]              << 16)    |
      61                 :          0 :                                   (cam->addr[5]              << 24);
      62                 :          0 :                         break;
      63                 :          0 :                 default:
      64                 :          0 :                         j = (i - 2) << 2;
      65                 :          0 :                         content = (key->key[j])                      |
      66                 :          0 :                                   (key->key[j + 1]   << 8)     |
      67                 :          0 :                                   (key->key[j + 2]   << 16)    |
      68                 :          0 :                                   (key->key[j + 3]   << 24);
      69                 :          0 :                         break;
      70                 :            :                 }
      71                 :            : 
      72                 :          0 :                 command = write_cmd | (addr + i);
      73                 :          0 :                 rtw_write32(rtwdev, RTW_SEC_WRITE_REG, content);
      74                 :          0 :                 rtw_write32(rtwdev, RTW_SEC_CMD_REG, command);
      75                 :            :         }
      76                 :          0 : }
      77                 :            : 
      78                 :          0 : void rtw_sec_clear_cam(struct rtw_dev *rtwdev,
      79                 :            :                        struct rtw_sec_desc *sec,
      80                 :            :                        u8 hw_key_idx)
      81                 :            : {
      82                 :          0 :         struct rtw_cam_entry *cam = &sec->cam_table[hw_key_idx];
      83                 :          0 :         u32 write_cmd;
      84                 :          0 :         u32 command;
      85                 :          0 :         u32 addr;
      86                 :            : 
      87                 :          0 :         clear_bit(hw_key_idx, sec->cam_map);
      88                 :          0 :         cam->valid = false;
      89                 :          0 :         cam->key = NULL;
      90                 :          0 :         eth_zero_addr(cam->addr);
      91                 :            : 
      92                 :          0 :         write_cmd = RTW_SEC_CMD_WRITE_ENABLE | RTW_SEC_CMD_POLLING;
      93                 :          0 :         addr = hw_key_idx << RTW_SEC_CAM_ENTRY_SHIFT;
      94                 :          0 :         command = write_cmd | addr;
      95                 :          0 :         rtw_write32(rtwdev, RTW_SEC_WRITE_REG, 0);
      96                 :          0 :         rtw_write32(rtwdev, RTW_SEC_CMD_REG, command);
      97                 :          0 : }
      98                 :            : 
      99                 :          0 : u8 rtw_sec_cam_pg_backup(struct rtw_dev *rtwdev, u8 *used_cam)
     100                 :            : {
     101                 :          0 :         struct rtw_sec_desc *sec = &rtwdev->sec;
     102                 :          0 :         u8 offset = 0;
     103                 :          0 :         u8 count, n;
     104                 :            : 
     105         [ #  # ]:          0 :         if (!used_cam)
     106                 :            :                 return 0;
     107                 :            : 
     108         [ #  # ]:          0 :         for (count = 0; count < MAX_PG_CAM_BACKUP_NUM; count++) {
     109                 :          0 :                 n = find_next_bit(sec->cam_map, RTW_MAX_SEC_CAM_NUM, offset);
     110         [ #  # ]:          0 :                 if (n == RTW_MAX_SEC_CAM_NUM)
     111                 :            :                         break;
     112                 :            : 
     113                 :          0 :                 used_cam[count] = n;
     114                 :          0 :                 offset = n + 1;
     115                 :            :         }
     116                 :            : 
     117                 :            :         return count;
     118                 :            : }
     119                 :            : 
     120                 :          0 : void rtw_sec_enable_sec_engine(struct rtw_dev *rtwdev)
     121                 :            : {
     122                 :          0 :         struct rtw_sec_desc *sec = &rtwdev->sec;
     123                 :          0 :         u16 ctrl_reg;
     124                 :          0 :         u16 sec_config;
     125                 :            : 
     126                 :            :         /* default use default key search for now */
     127                 :          0 :         sec->default_key_search = true;
     128                 :            : 
     129                 :          0 :         ctrl_reg = rtw_read16(rtwdev, REG_CR);
     130                 :          0 :         ctrl_reg |= RTW_SEC_ENGINE_EN;
     131                 :          0 :         rtw_write16(rtwdev, REG_CR, ctrl_reg);
     132                 :            : 
     133                 :          0 :         sec_config = rtw_read16(rtwdev, RTW_SEC_CONFIG);
     134                 :            : 
     135                 :          0 :         sec_config |= RTW_SEC_TX_DEC_EN | RTW_SEC_RX_DEC_EN;
     136         [ #  # ]:          0 :         if (sec->default_key_search)
     137                 :          0 :                 sec_config |= RTW_SEC_TX_UNI_USE_DK | RTW_SEC_RX_UNI_USE_DK |
     138                 :            :                               RTW_SEC_TX_BC_USE_DK | RTW_SEC_RX_BC_USE_DK;
     139                 :            : 
     140                 :          0 :         rtw_write16(rtwdev, RTW_SEC_CONFIG, sec_config);
     141                 :          0 : }