cam.c 9.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343
  1. /******************************************************************************
  2. *
  3. * Copyright(c) 2009-2012 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. * The full GNU General Public License is included in this distribution in the
  15. * file called LICENSE.
  16. *
  17. * Contact Information:
  18. * wlanfae <wlanfae@realtek.com>
  19. * Realtek Corporation, No. 2, Innovation Road II, Hsinchu Science Park,
  20. * Hsinchu 300, Taiwan.
  21. *
  22. * Larry Finger <Larry.Finger@lwfinger.net>
  23. *
  24. *****************************************************************************/
  25. #include "wifi.h"
  26. #include "cam.h"
  27. #include <linux/export.h>
  28. void rtl_cam_reset_sec_info(struct ieee80211_hw *hw)
  29. {
  30. struct rtl_priv *rtlpriv = rtl_priv(hw);
  31. rtlpriv->sec.use_defaultkey = false;
  32. rtlpriv->sec.pairwise_enc_algorithm = NO_ENCRYPTION;
  33. rtlpriv->sec.group_enc_algorithm = NO_ENCRYPTION;
  34. memset(rtlpriv->sec.key_buf, 0, KEY_BUF_SIZE * MAX_KEY_LEN);
  35. memset(rtlpriv->sec.key_len, 0, KEY_BUF_SIZE);
  36. rtlpriv->sec.pairwise_key = NULL;
  37. }
  38. static void rtl_cam_program_entry(struct ieee80211_hw *hw, u32 entry_no,
  39. u8 *mac_addr, u8 *key_cont_128, u16 us_config)
  40. {
  41. struct rtl_priv *rtlpriv = rtl_priv(hw);
  42. u32 target_command;
  43. u32 target_content = 0;
  44. int entry_i;
  45. RT_PRINT_DATA(rtlpriv, COMP_SEC, DBG_DMESG, "Key content :",
  46. key_cont_128, 16);
  47. /* 0-1 config + mac, 2-5 fill 128key,6-7 are reserved */
  48. for (entry_i = CAM_CONTENT_COUNT - 1; entry_i >= 0; entry_i--) {
  49. target_command = entry_i + CAM_CONTENT_COUNT * entry_no;
  50. target_command = target_command | BIT(31) | BIT(16);
  51. if (entry_i == 0) {
  52. target_content = (u32) (*(mac_addr + 0)) << 16 |
  53. (u32) (*(mac_addr + 1)) << 24 | (u32) us_config;
  54. rtl_write_dword(rtlpriv, rtlpriv->cfg->maps[WCAMI],
  55. target_content);
  56. rtl_write_dword(rtlpriv, rtlpriv->cfg->maps[RWCAM],
  57. target_command);
  58. RT_TRACE(rtlpriv, COMP_SEC, DBG_LOUD,
  59. "WRITE %x: %x\n",
  60. rtlpriv->cfg->maps[WCAMI], target_content);
  61. RT_TRACE(rtlpriv, COMP_SEC, DBG_LOUD,
  62. "The Key ID is %d\n", entry_no);
  63. RT_TRACE(rtlpriv, COMP_SEC, DBG_LOUD,
  64. "WRITE %x: %x\n",
  65. rtlpriv->cfg->maps[RWCAM], target_command);
  66. } else if (entry_i == 1) {
  67. target_content = (u32) (*(mac_addr + 5)) << 24 |
  68. (u32) (*(mac_addr + 4)) << 16 |
  69. (u32) (*(mac_addr + 3)) << 8 |
  70. (u32) (*(mac_addr + 2));
  71. rtl_write_dword(rtlpriv, rtlpriv->cfg->maps[WCAMI],
  72. target_content);
  73. rtl_write_dword(rtlpriv, rtlpriv->cfg->maps[RWCAM],
  74. target_command);
  75. RT_TRACE(rtlpriv, COMP_SEC, DBG_LOUD,
  76. "WRITE A4: %x\n", target_content);
  77. RT_TRACE(rtlpriv, COMP_SEC, DBG_LOUD,
  78. "WRITE A0: %x\n", target_command);
  79. } else {
  80. target_content =
  81. (u32) (*(key_cont_128 + (entry_i * 4 - 8) + 3)) <<
  82. 24 | (u32) (*(key_cont_128 + (entry_i * 4 - 8) + 2))
  83. << 16 |
  84. (u32) (*(key_cont_128 + (entry_i * 4 - 8) + 1)) << 8
  85. | (u32) (*(key_cont_128 + (entry_i * 4 - 8) + 0));
  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. RT_TRACE(rtlpriv, COMP_SEC, DBG_LOUD,
  91. "WRITE A4: %x\n", target_content);
  92. RT_TRACE(rtlpriv, COMP_SEC, DBG_LOUD,
  93. "WRITE A0: %x\n", target_command);
  94. }
  95. }
  96. RT_TRACE(rtlpriv, COMP_SEC, DBG_LOUD,
  97. "after set key, usconfig:%x\n", us_config);
  98. }
  99. u8 rtl_cam_add_one_entry(struct ieee80211_hw *hw, u8 *mac_addr,
  100. u32 ul_key_id, u32 ul_entry_idx, u32 ul_enc_alg,
  101. u32 ul_default_key, u8 *key_content)
  102. {
  103. u32 us_config;
  104. struct rtl_priv *rtlpriv = rtl_priv(hw);
  105. RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG,
  106. "EntryNo:%x, ulKeyId=%x, ulEncAlg=%x, ulUseDK=%x MacAddr %pM\n",
  107. ul_entry_idx, ul_key_id, ul_enc_alg,
  108. ul_default_key, mac_addr);
  109. if (ul_key_id == TOTAL_CAM_ENTRY) {
  110. RT_TRACE(rtlpriv, COMP_ERR, DBG_WARNING,
  111. "ulKeyId exceed!\n");
  112. return 0;
  113. }
  114. if (ul_default_key == 1)
  115. us_config = CFG_VALID | ((u16) (ul_enc_alg) << 2);
  116. else
  117. us_config = CFG_VALID | ((ul_enc_alg) << 2) | ul_key_id;
  118. rtl_cam_program_entry(hw, ul_entry_idx, mac_addr,
  119. (u8 *)key_content, us_config);
  120. RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG, "end\n");
  121. return 1;
  122. }
  123. EXPORT_SYMBOL(rtl_cam_add_one_entry);
  124. int rtl_cam_delete_one_entry(struct ieee80211_hw *hw,
  125. u8 *mac_addr, u32 ul_key_id)
  126. {
  127. u32 ul_command;
  128. struct rtl_priv *rtlpriv = rtl_priv(hw);
  129. RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG, "key_idx:%d\n", ul_key_id);
  130. ul_command = ul_key_id * CAM_CONTENT_COUNT;
  131. ul_command = ul_command | BIT(31) | BIT(16);
  132. rtl_write_dword(rtlpriv, rtlpriv->cfg->maps[WCAMI], 0);
  133. rtl_write_dword(rtlpriv, rtlpriv->cfg->maps[RWCAM], ul_command);
  134. RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG,
  135. "rtl_cam_delete_one_entry(): WRITE A4: %x\n", 0);
  136. RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG,
  137. "rtl_cam_delete_one_entry(): WRITE A0: %x\n", ul_command);
  138. return 0;
  139. }
  140. EXPORT_SYMBOL(rtl_cam_delete_one_entry);
  141. void rtl_cam_reset_all_entry(struct ieee80211_hw *hw)
  142. {
  143. u32 ul_command;
  144. struct rtl_priv *rtlpriv = rtl_priv(hw);
  145. ul_command = BIT(31) | BIT(30);
  146. rtl_write_dword(rtlpriv, rtlpriv->cfg->maps[RWCAM], ul_command);
  147. }
  148. EXPORT_SYMBOL(rtl_cam_reset_all_entry);
  149. void rtl_cam_mark_invalid(struct ieee80211_hw *hw, u8 uc_index)
  150. {
  151. struct rtl_priv *rtlpriv = rtl_priv(hw);
  152. u32 ul_command;
  153. u32 ul_content;
  154. u32 ul_enc_algo = rtlpriv->cfg->maps[SEC_CAM_AES];
  155. switch (rtlpriv->sec.pairwise_enc_algorithm) {
  156. case WEP40_ENCRYPTION:
  157. ul_enc_algo = rtlpriv->cfg->maps[SEC_CAM_WEP40];
  158. break;
  159. case WEP104_ENCRYPTION:
  160. ul_enc_algo = rtlpriv->cfg->maps[SEC_CAM_WEP104];
  161. break;
  162. case TKIP_ENCRYPTION:
  163. ul_enc_algo = rtlpriv->cfg->maps[SEC_CAM_TKIP];
  164. break;
  165. case AESCCMP_ENCRYPTION:
  166. ul_enc_algo = rtlpriv->cfg->maps[SEC_CAM_AES];
  167. break;
  168. default:
  169. ul_enc_algo = rtlpriv->cfg->maps[SEC_CAM_AES];
  170. }
  171. ul_content = (uc_index & 3) | ((u16) (ul_enc_algo) << 2);
  172. ul_content |= BIT(15);
  173. ul_command = CAM_CONTENT_COUNT * uc_index;
  174. ul_command = ul_command | BIT(31) | BIT(16);
  175. rtl_write_dword(rtlpriv, rtlpriv->cfg->maps[WCAMI], ul_content);
  176. rtl_write_dword(rtlpriv, rtlpriv->cfg->maps[RWCAM], ul_command);
  177. RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG,
  178. "rtl_cam_mark_invalid(): WRITE A4: %x\n", ul_content);
  179. RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG,
  180. "rtl_cam_mark_invalid(): WRITE A0: %x\n", ul_command);
  181. }
  182. EXPORT_SYMBOL(rtl_cam_mark_invalid);
  183. void rtl_cam_empty_entry(struct ieee80211_hw *hw, u8 uc_index)
  184. {
  185. struct rtl_priv *rtlpriv = rtl_priv(hw);
  186. u32 ul_command;
  187. u32 ul_content;
  188. u32 ul_encalgo = rtlpriv->cfg->maps[SEC_CAM_AES];
  189. u8 entry_i;
  190. switch (rtlpriv->sec.pairwise_enc_algorithm) {
  191. case WEP40_ENCRYPTION:
  192. ul_encalgo = rtlpriv->cfg->maps[SEC_CAM_WEP40];
  193. break;
  194. case WEP104_ENCRYPTION:
  195. ul_encalgo = rtlpriv->cfg->maps[SEC_CAM_WEP104];
  196. break;
  197. case TKIP_ENCRYPTION:
  198. ul_encalgo = rtlpriv->cfg->maps[SEC_CAM_TKIP];
  199. break;
  200. case AESCCMP_ENCRYPTION:
  201. ul_encalgo = rtlpriv->cfg->maps[SEC_CAM_AES];
  202. break;
  203. default:
  204. ul_encalgo = rtlpriv->cfg->maps[SEC_CAM_AES];
  205. }
  206. for (entry_i = 0; entry_i < CAM_CONTENT_COUNT; entry_i++) {
  207. if (entry_i == 0) {
  208. ul_content =
  209. (uc_index & 0x03) | ((u16) (ul_encalgo) << 2);
  210. ul_content |= BIT(15);
  211. } else {
  212. ul_content = 0;
  213. }
  214. ul_command = CAM_CONTENT_COUNT * uc_index + entry_i;
  215. ul_command = ul_command | BIT(31) | BIT(16);
  216. rtl_write_dword(rtlpriv, rtlpriv->cfg->maps[WCAMI], ul_content);
  217. rtl_write_dword(rtlpriv, rtlpriv->cfg->maps[RWCAM], ul_command);
  218. RT_TRACE(rtlpriv, COMP_SEC, DBG_LOUD,
  219. "rtl_cam_empty_entry(): WRITE A4: %x\n",
  220. ul_content);
  221. RT_TRACE(rtlpriv, COMP_SEC, DBG_LOUD,
  222. "rtl_cam_empty_entry(): WRITE A0: %x\n",
  223. ul_command);
  224. }
  225. }
  226. EXPORT_SYMBOL(rtl_cam_empty_entry);
  227. u8 rtl_cam_get_free_entry(struct ieee80211_hw *hw, u8 *sta_addr)
  228. {
  229. struct rtl_priv *rtlpriv = rtl_priv(hw);
  230. u32 bitmap = (rtlpriv->sec.hwsec_cam_bitmap) >> 4;
  231. u8 entry_idx = 0;
  232. u8 i, *addr;
  233. if (NULL == sta_addr) {
  234. pr_err("sta_addr is NULL.\n");
  235. return TOTAL_CAM_ENTRY;
  236. }
  237. /* Does STA already exist? */
  238. for (i = 4; i < TOTAL_CAM_ENTRY; i++) {
  239. addr = rtlpriv->sec.hwsec_cam_sta_addr[i];
  240. if (ether_addr_equal_unaligned(addr, sta_addr))
  241. return i;
  242. }
  243. /* Get a free CAM entry. */
  244. for (entry_idx = 4; entry_idx < TOTAL_CAM_ENTRY; entry_idx++) {
  245. if ((bitmap & BIT(0)) == 0) {
  246. pr_err("-----hwsec_cam_bitmap: 0x%x entry_idx=%d\n",
  247. rtlpriv->sec.hwsec_cam_bitmap, entry_idx);
  248. rtlpriv->sec.hwsec_cam_bitmap |= BIT(0) << entry_idx;
  249. memcpy(rtlpriv->sec.hwsec_cam_sta_addr[entry_idx],
  250. sta_addr, ETH_ALEN);
  251. return entry_idx;
  252. }
  253. bitmap = bitmap >> 1;
  254. }
  255. return TOTAL_CAM_ENTRY;
  256. }
  257. EXPORT_SYMBOL(rtl_cam_get_free_entry);
  258. void rtl_cam_del_entry(struct ieee80211_hw *hw, u8 *sta_addr)
  259. {
  260. struct rtl_priv *rtlpriv = rtl_priv(hw);
  261. u32 bitmap;
  262. u8 i, *addr;
  263. if (NULL == sta_addr) {
  264. pr_err("sta_addr is NULL.\n");
  265. return;
  266. }
  267. if (is_zero_ether_addr(sta_addr)) {
  268. pr_err("sta_addr is %pM\n", sta_addr);
  269. return;
  270. }
  271. /* Does STA already exist? */
  272. for (i = 4; i < TOTAL_CAM_ENTRY; i++) {
  273. addr = rtlpriv->sec.hwsec_cam_sta_addr[i];
  274. bitmap = (rtlpriv->sec.hwsec_cam_bitmap) >> i;
  275. if (((bitmap & BIT(0)) == BIT(0)) &&
  276. (ether_addr_equal_unaligned(addr, sta_addr))) {
  277. /* Remove from HW Security CAM */
  278. eth_zero_addr(rtlpriv->sec.hwsec_cam_sta_addr[i]);
  279. rtlpriv->sec.hwsec_cam_bitmap &= ~(BIT(0) << i);
  280. RT_TRACE(rtlpriv, COMP_SEC, DBG_DMESG,
  281. "&&&&&&&&&del entry %d\n", i);
  282. }
  283. }
  284. return;
  285. }
  286. EXPORT_SYMBOL(rtl_cam_del_entry);