1 /******************************************************************************
2  *
3  * Copyright(c) 2009-2013  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 <linux/vmalloc.h>
27 #include <linux/module.h>
28 
29 #include "rtl_btc.h"
30 #include "halbt_precomp.h"
31 
32 static struct rtl_btc_ops rtl_btc_operation = {
33 	.btc_init_variables = rtl_btc_init_variables,
34 	.btc_init_variables_wifi_only = rtl_btc_init_variables_wifi_only,
35 	.btc_deinit_variables = rtl_btc_deinit_variables,
36 	.btc_init_hal_vars = rtl_btc_init_hal_vars,
37 	.btc_power_on_setting = rtl_btc_power_on_setting,
38 	.btc_init_hw_config = rtl_btc_init_hw_config,
39 	.btc_init_hw_config_wifi_only = rtl_btc_init_hw_config_wifi_only,
40 	.btc_ips_notify = rtl_btc_ips_notify,
41 	.btc_lps_notify = rtl_btc_lps_notify,
42 	.btc_scan_notify = rtl_btc_scan_notify,
43 	.btc_scan_notify_wifi_only = rtl_btc_scan_notify_wifi_only,
44 	.btc_connect_notify = rtl_btc_connect_notify,
45 	.btc_mediastatus_notify = rtl_btc_mediastatus_notify,
46 	.btc_periodical = rtl_btc_periodical,
47 	.btc_halt_notify = rtl_btc_halt_notify,
48 	.btc_btinfo_notify = rtl_btc_btinfo_notify,
49 	.btc_btmpinfo_notify = rtl_btc_btmpinfo_notify,
50 	.btc_is_limited_dig = rtl_btc_is_limited_dig,
51 	.btc_is_disable_edca_turbo = rtl_btc_is_disable_edca_turbo,
52 	.btc_is_bt_disabled = rtl_btc_is_bt_disabled,
53 	.btc_special_packet_notify = rtl_btc_special_packet_notify,
54 	.btc_switch_band_notify = rtl_btc_switch_band_notify,
55 	.btc_switch_band_notify_wifi_only = rtl_btc_switch_band_notify_wifionly,
56 	.btc_record_pwr_mode = rtl_btc_record_pwr_mode,
57 	.btc_get_lps_val = rtl_btc_get_lps_val,
58 	.btc_get_rpwm_val = rtl_btc_get_rpwm_val,
59 	.btc_is_bt_ctrl_lps = rtl_btc_is_bt_ctrl_lps,
60 	.btc_is_bt_lps_on = rtl_btc_is_bt_lps_on,
61 	.btc_get_ampdu_cfg = rtl_btc_get_ampdu_cfg,
62 	.btc_display_bt_coex_info = rtl_btc_display_bt_coex_info,
63 };
64 
65 void rtl_btc_display_bt_coex_info(struct rtl_priv *rtlpriv, struct seq_file *m)
66 {
67 	struct btc_coexist *btcoexist = rtl_btc_coexist(rtlpriv);
68 
69 	if (!btcoexist) {
70 		seq_puts(m, "btc_coexist context is NULL!\n");
71 		return;
72 	}
73 
74 	exhalbtc_display_bt_coex_info(btcoexist, m);
75 }
76 
77 void rtl_btc_record_pwr_mode(struct rtl_priv *rtlpriv, u8 *buf, u8 len)
78 {
79 	struct btc_coexist *btcoexist = rtl_btc_coexist(rtlpriv);
80 	u8 safe_len;
81 
82 	if (!btcoexist)
83 		return;
84 
85 	safe_len = sizeof(btcoexist->pwr_mode_val);
86 
87 	if (safe_len > len)
88 		safe_len = len;
89 
90 	memcpy(btcoexist->pwr_mode_val, buf, safe_len);
91 }
92 
93 u8 rtl_btc_get_lps_val(struct rtl_priv *rtlpriv)
94 {
95 	struct btc_coexist *btcoexist = rtl_btc_coexist(rtlpriv);
96 
97 	if (!btcoexist)
98 		return 0;
99 
100 	return btcoexist->bt_info.lps_val;
101 }
102 
103 u8 rtl_btc_get_rpwm_val(struct rtl_priv *rtlpriv)
104 {
105 	struct btc_coexist *btcoexist = rtl_btc_coexist(rtlpriv);
106 
107 	if (!btcoexist)
108 		return 0;
109 
110 	return btcoexist->bt_info.rpwm_val;
111 }
112 
113 bool rtl_btc_is_bt_ctrl_lps(struct rtl_priv *rtlpriv)
114 {
115 	struct btc_coexist *btcoexist = rtl_btc_coexist(rtlpriv);
116 
117 	if (!btcoexist)
118 		return false;
119 
120 	return btcoexist->bt_info.bt_ctrl_lps;
121 }
122 
123 bool rtl_btc_is_bt_lps_on(struct rtl_priv *rtlpriv)
124 {
125 	struct btc_coexist *btcoexist = rtl_btc_coexist(rtlpriv);
126 
127 	if (!btcoexist)
128 		return false;
129 
130 	return btcoexist->bt_info.bt_lps_on;
131 }
132 
133 void rtl_btc_get_ampdu_cfg(struct rtl_priv *rtlpriv, u8 *reject_agg,
134 			   u8 *ctrl_agg_size, u8 *agg_size)
135 {
136 	struct btc_coexist *btcoexist = rtl_btc_coexist(rtlpriv);
137 
138 	if (!btcoexist) {
139 		*reject_agg = false;
140 		*ctrl_agg_size = false;
141 		return;
142 	}
143 
144 	if (reject_agg)
145 		*reject_agg = btcoexist->bt_info.reject_agg_pkt;
146 	if (ctrl_agg_size)
147 		*ctrl_agg_size = btcoexist->bt_info.bt_ctrl_agg_buf_size;
148 	if (agg_size)
149 		*agg_size = btcoexist->bt_info.agg_buf_size;
150 }
151 
152 static void rtl_btc_alloc_variable(struct rtl_priv *rtlpriv, bool wifi_only)
153 {
154 	if (wifi_only)
155 		rtlpriv->btcoexist.wifi_only_context =
156 			kzalloc(sizeof(struct wifi_only_cfg), GFP_KERNEL);
157 	else
158 		rtlpriv->btcoexist.btc_context =
159 			kzalloc(sizeof(struct btc_coexist), GFP_KERNEL);
160 }
161 
162 static void rtl_btc_free_variable(struct rtl_priv *rtlpriv)
163 {
164 	kfree(rtlpriv->btcoexist.btc_context);
165 	rtlpriv->btcoexist.btc_context = NULL;
166 
167 	kfree(rtlpriv->btcoexist.wifi_only_context);
168 	rtlpriv->btcoexist.wifi_only_context = NULL;
169 }
170 
171 void rtl_btc_init_variables(struct rtl_priv *rtlpriv)
172 {
173 	rtl_btc_alloc_variable(rtlpriv, false);
174 
175 	exhalbtc_initlize_variables(rtlpriv);
176 	exhalbtc_bind_bt_coex_withadapter(rtlpriv);
177 }
178 
179 void rtl_btc_init_variables_wifi_only(struct rtl_priv *rtlpriv)
180 {
181 	rtl_btc_alloc_variable(rtlpriv, true);
182 
183 	exhalbtc_initlize_variables_wifi_only(rtlpriv);
184 }
185 
186 void rtl_btc_deinit_variables(struct rtl_priv *rtlpriv)
187 {
188 	rtl_btc_free_variable(rtlpriv);
189 }
190 
191 void rtl_btc_init_hal_vars(struct rtl_priv *rtlpriv)
192 {
193 	/* move ant_num, bt_type and single_ant_path to
194 	 * exhalbtc_bind_bt_coex_withadapter()
195 	 */
196 }
197 
198 void rtl_btc_power_on_setting(struct rtl_priv *rtlpriv)
199 {
200 	struct btc_coexist *btcoexist = rtl_btc_coexist(rtlpriv);
201 
202 	if (!btcoexist)
203 		return;
204 
205 	exhalbtc_power_on_setting(btcoexist);
206 }
207 
208 void rtl_btc_init_hw_config(struct rtl_priv *rtlpriv)
209 {
210 	struct btc_coexist *btcoexist = rtl_btc_coexist(rtlpriv);
211 
212 	u8 bt_exist;
213 
214 	bt_exist = rtl_get_hwpg_bt_exist(rtlpriv);
215 	RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
216 		"%s, bt_exist is %d\n", __func__, bt_exist);
217 
218 	if (!btcoexist)
219 		return;
220 
221 	exhalbtc_init_hw_config(btcoexist, !bt_exist);
222 	exhalbtc_init_coex_dm(btcoexist);
223 }
224 
225 void rtl_btc_init_hw_config_wifi_only(struct rtl_priv *rtlpriv)
226 {
227 	struct wifi_only_cfg *wifionly_cfg = rtl_btc_wifi_only(rtlpriv);
228 
229 	if (!wifionly_cfg)
230 		return;
231 
232 	exhalbtc_init_hw_config_wifi_only(wifionly_cfg);
233 }
234 
235 void rtl_btc_ips_notify(struct rtl_priv *rtlpriv, u8 type)
236 {
237 	struct btc_coexist *btcoexist = rtl_btc_coexist(rtlpriv);
238 
239 	if (!btcoexist)
240 		return;
241 
242 	exhalbtc_ips_notify(btcoexist, type);
243 
244 	if (type == ERFON) {
245 		/* In some situation, it doesn't scan after leaving IPS, and
246 		 * this will cause btcoex in wrong state.
247 		 */
248 		exhalbtc_scan_notify(btcoexist, 1);
249 		exhalbtc_scan_notify(btcoexist, 0);
250 	}
251 }
252 
253 void rtl_btc_lps_notify(struct rtl_priv *rtlpriv, u8 type)
254 {
255 	struct btc_coexist *btcoexist = rtl_btc_coexist(rtlpriv);
256 
257 	if (!btcoexist)
258 		return;
259 
260 	exhalbtc_lps_notify(btcoexist, type);
261 }
262 
263 void rtl_btc_scan_notify(struct rtl_priv *rtlpriv, u8 scantype)
264 {
265 	struct btc_coexist *btcoexist = rtl_btc_coexist(rtlpriv);
266 
267 	if (!btcoexist)
268 		return;
269 
270 	exhalbtc_scan_notify(btcoexist, scantype);
271 }
272 
273 void rtl_btc_scan_notify_wifi_only(struct rtl_priv *rtlpriv, u8 scantype)
274 {
275 	struct rtl_hal *rtlhal = rtl_hal(rtlpriv);
276 	struct wifi_only_cfg *wifionly_cfg = rtl_btc_wifi_only(rtlpriv);
277 	u8 is_5g = (rtlhal->current_bandtype == BAND_ON_5G);
278 
279 	if (!wifionly_cfg)
280 		return;
281 
282 	exhalbtc_scan_notify_wifi_only(wifionly_cfg, is_5g);
283 }
284 
285 void rtl_btc_connect_notify(struct rtl_priv *rtlpriv, u8 action)
286 {
287 	struct btc_coexist *btcoexist = rtl_btc_coexist(rtlpriv);
288 
289 	if (!btcoexist)
290 		return;
291 
292 	exhalbtc_connect_notify(btcoexist, action);
293 }
294 
295 void rtl_btc_mediastatus_notify(struct rtl_priv *rtlpriv,
296 				enum rt_media_status mstatus)
297 {
298 	struct btc_coexist *btcoexist = rtl_btc_coexist(rtlpriv);
299 
300 	if (!btcoexist)
301 		return;
302 
303 	exhalbtc_mediastatus_notify(btcoexist, mstatus);
304 }
305 
306 void rtl_btc_periodical(struct rtl_priv *rtlpriv)
307 {
308 	struct btc_coexist *btcoexist = rtl_btc_coexist(rtlpriv);
309 
310 	if (!btcoexist)
311 		return;
312 
313 	/*rtl_bt_dm_monitor();*/
314 	exhalbtc_periodical(btcoexist);
315 }
316 
317 void rtl_btc_halt_notify(struct rtl_priv *rtlpriv)
318 {
319 	struct btc_coexist *btcoexist = rtl_btc_coexist(rtlpriv);
320 
321 	if (!btcoexist)
322 		return;
323 
324 	exhalbtc_halt_notify(btcoexist);
325 }
326 
327 void rtl_btc_btinfo_notify(struct rtl_priv *rtlpriv, u8 *tmp_buf, u8 length)
328 {
329 	struct btc_coexist *btcoexist = rtl_btc_coexist(rtlpriv);
330 
331 	if (!btcoexist)
332 		return;
333 
334 	exhalbtc_bt_info_notify(btcoexist, tmp_buf, length);
335 }
336 
337 void rtl_btc_btmpinfo_notify(struct rtl_priv *rtlpriv, u8 *tmp_buf, u8 length)
338 {
339 	struct btc_coexist *btcoexist = rtl_btc_coexist(rtlpriv);
340 	u8 extid, seq, len;
341 	u16 bt_real_fw_ver;
342 	u8 bt_fw_ver;
343 	u8 *data;
344 
345 	if (!btcoexist)
346 		return;
347 
348 	if ((length < 4) || (!tmp_buf))
349 		return;
350 
351 	extid = tmp_buf[0];
352 	/* not response from BT FW then exit*/
353 	if (extid != 1) /* C2H_TRIG_BY_BT_FW = 1 */
354 		return;
355 
356 	len = tmp_buf[1] >> 4;
357 	seq = tmp_buf[2] >> 4;
358 	data = &tmp_buf[3];
359 
360 	/* BT Firmware version response */
361 	switch (seq) {
362 	case BT_SEQ_GET_BT_VERSION:
363 		bt_real_fw_ver = tmp_buf[3] | (tmp_buf[4] << 8);
364 		bt_fw_ver = tmp_buf[5];
365 
366 		btcoexist->bt_info.bt_real_fw_ver = bt_real_fw_ver;
367 		btcoexist->bt_info.bt_fw_ver = bt_fw_ver;
368 		break;
369 	case BT_SEQ_GET_AFH_MAP_L:
370 		btcoexist->bt_info.afh_map_l = le32_to_cpu(*(__le32 *)data);
371 		break;
372 	case BT_SEQ_GET_AFH_MAP_M:
373 		btcoexist->bt_info.afh_map_m = le32_to_cpu(*(__le32 *)data);
374 		break;
375 	case BT_SEQ_GET_AFH_MAP_H:
376 		btcoexist->bt_info.afh_map_h = le16_to_cpu(*(__le16 *)data);
377 		break;
378 	case BT_SEQ_GET_BT_COEX_SUPPORTED_FEATURE:
379 		btcoexist->bt_info.bt_supported_feature = tmp_buf[3] |
380 							  (tmp_buf[4] << 8);
381 		break;
382 	case BT_SEQ_GET_BT_COEX_SUPPORTED_VERSION:
383 		btcoexist->bt_info.bt_supported_version = tmp_buf[3] |
384 							  (tmp_buf[4] << 8);
385 		break;
386 	case BT_SEQ_GET_BT_ANT_DET_VAL:
387 		btcoexist->bt_info.bt_ant_det_val = tmp_buf[3];
388 		break;
389 	case BT_SEQ_GET_BT_BLE_SCAN_PARA:
390 		btcoexist->bt_info.bt_ble_scan_para = tmp_buf[3] |
391 						      (tmp_buf[4] << 8) |
392 						      (tmp_buf[5] << 16) |
393 						      (tmp_buf[6] << 24);
394 		break;
395 	case BT_SEQ_GET_BT_BLE_SCAN_TYPE:
396 		btcoexist->bt_info.bt_ble_scan_type = tmp_buf[3];
397 		break;
398 	case BT_SEQ_GET_BT_DEVICE_INFO:
399 		btcoexist->bt_info.bt_device_info =
400 						le32_to_cpu(*(__le32 *)data);
401 		break;
402 	case BT_OP_GET_BT_FORBIDDEN_SLOT_VAL:
403 		btcoexist->bt_info.bt_forb_slot_val =
404 						le32_to_cpu(*(__le32 *)data);
405 		break;
406 	}
407 
408 	RT_TRACE(rtlpriv, COMP_BT_COEXIST, DBG_LOUD,
409 		 "btmpinfo complete req_num=%d\n", seq);
410 
411 	complete(&btcoexist->bt_mp_comp);
412 }
413 
414 bool rtl_btc_is_limited_dig(struct rtl_priv *rtlpriv)
415 {
416 	struct btc_coexist *btcoexist = rtl_btc_coexist(rtlpriv);
417 
418 	if (!btcoexist)
419 		return false;
420 
421 	return btcoexist->bt_info.limited_dig;
422 }
423 
424 bool rtl_btc_is_disable_edca_turbo(struct rtl_priv *rtlpriv)
425 {
426 	bool bt_change_edca = false;
427 	u32 cur_edca_val;
428 	u32 edca_bt_hs_uplink = 0x5ea42b, edca_bt_hs_downlink = 0x5ea42b;
429 	u32 edca_hs;
430 	u32 edca_addr = 0x504;
431 
432 	cur_edca_val = rtl_read_dword(rtlpriv, edca_addr);
433 	if (halbtc_is_wifi_uplink(rtlpriv)) {
434 		if (cur_edca_val != edca_bt_hs_uplink) {
435 			edca_hs = edca_bt_hs_uplink;
436 			bt_change_edca = true;
437 		}
438 	} else {
439 		if (cur_edca_val != edca_bt_hs_downlink) {
440 			edca_hs = edca_bt_hs_downlink;
441 			bt_change_edca = true;
442 		}
443 	}
444 
445 	if (bt_change_edca)
446 		rtl_write_dword(rtlpriv, edca_addr, edca_hs);
447 
448 	return true;
449 }
450 
451 bool rtl_btc_is_bt_disabled(struct rtl_priv *rtlpriv)
452 {
453 	struct btc_coexist *btcoexist = rtl_btc_coexist(rtlpriv);
454 
455 	if (!btcoexist)
456 		return true;
457 
458 	/* It seems 'bt_disabled' is never be initialized or set. */
459 	if (btcoexist->bt_info.bt_disabled)
460 		return true;
461 	else
462 		return false;
463 }
464 
465 void rtl_btc_special_packet_notify(struct rtl_priv *rtlpriv, u8 pkt_type)
466 {
467 	struct btc_coexist *btcoexist = rtl_btc_coexist(rtlpriv);
468 
469 	if (!btcoexist)
470 		return;
471 
472 	return exhalbtc_special_packet_notify(btcoexist, pkt_type);
473 }
474 
475 void rtl_btc_switch_band_notify(struct rtl_priv *rtlpriv, u8 band_type,
476 				bool scanning)
477 {
478 	struct btc_coexist *btcoexist = rtl_btc_coexist(rtlpriv);
479 	u8 type = BTC_NOT_SWITCH;
480 
481 	if (!btcoexist)
482 		return;
483 
484 	switch (band_type) {
485 	case BAND_ON_2_4G:
486 		if (scanning)
487 			type = BTC_SWITCH_TO_24G;
488 		else
489 			type = BTC_SWITCH_TO_24G_NOFORSCAN;
490 		break;
491 
492 	case BAND_ON_5G:
493 		type = BTC_SWITCH_TO_5G;
494 		break;
495 	}
496 
497 	if (type != BTC_NOT_SWITCH)
498 		exhalbtc_switch_band_notify(btcoexist, type);
499 }
500 
501 void rtl_btc_switch_band_notify_wifionly(struct rtl_priv *rtlpriv, u8 band_type,
502 					 bool scanning)
503 {
504 	struct wifi_only_cfg *wifionly_cfg = rtl_btc_wifi_only(rtlpriv);
505 	u8 is_5g = (band_type == BAND_ON_5G);
506 
507 	if (!wifionly_cfg)
508 		return;
509 
510 	exhalbtc_switch_band_notify_wifi_only(wifionly_cfg, is_5g);
511 }
512 
513 struct rtl_btc_ops *rtl_btc_get_ops_pointer(void)
514 {
515 	return &rtl_btc_operation;
516 }
517 EXPORT_SYMBOL(rtl_btc_get_ops_pointer);
518 
519 
520 enum rt_media_status mgnt_link_status_query(struct ieee80211_hw *hw)
521 {
522 	struct rtl_priv *rtlpriv = rtl_priv(hw);
523 	struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
524 	enum rt_media_status    m_status = RT_MEDIA_DISCONNECT;
525 
526 	u8 bibss = (mac->opmode == NL80211_IFTYPE_ADHOC) ? 1 : 0;
527 
528 	if (bibss || rtlpriv->mac80211.link_state >= MAC80211_LINKED)
529 		m_status = RT_MEDIA_CONNECT;
530 
531 	return m_status;
532 }
533 
534 u8 rtl_get_hwpg_bt_exist(struct rtl_priv *rtlpriv)
535 {
536 	return rtlpriv->btcoexist.btc_info.btcoexist;
537 }
538 
539 MODULE_AUTHOR("Page He	<page_he@realsil.com.cn>");
540 MODULE_AUTHOR("Realtek WlanFAE	<wlanfae@realtek.com>");
541 MODULE_AUTHOR("Larry Finger	<Larry.FInger@lwfinger.net>");
542 MODULE_LICENSE("GPL");
543 MODULE_DESCRIPTION("Realtek 802.11n PCI wireless core");
544 
545 static int __init rtl_btcoexist_module_init(void)
546 {
547 	return 0;
548 }
549 
550 static void __exit rtl_btcoexist_module_exit(void)
551 {
552 	return;
553 }
554 
555 module_init(rtl_btcoexist_module_init);
556 module_exit(rtl_btcoexist_module_exit);
557