1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright(c) 2009-2012  Realtek Corporation.*/
3 
4 #include "wifi.h"
5 #include "cam.h"
6 
7 #include <linux/moduleparam.h>
8 #include <linux/vmalloc.h>
9 
10 #ifdef CONFIG_RTLWIFI_DEBUG
11 void _rtl_dbg_print(struct rtl_priv *rtlpriv, u64 comp, int level,
12 		    const char *fmt, ...)
13 {
14 	if (unlikely((comp & rtlpriv->cfg->mod_params->debug_mask) &&
15 		     level <= rtlpriv->cfg->mod_params->debug_level)) {
16 		struct va_format vaf;
17 		va_list args;
18 
19 		va_start(args, fmt);
20 
21 		vaf.fmt = fmt;
22 		vaf.va = &args;
23 
24 		pr_info("%pV", &vaf);
25 
26 		va_end(args);
27 	}
28 }
29 EXPORT_SYMBOL_GPL(_rtl_dbg_print);
30 
31 void _rtl_dbg_print_data(struct rtl_priv *rtlpriv, u64 comp, int level,
32 			 const char *titlestring,
33 			 const void *hexdata, int hexdatalen)
34 {
35 	if (unlikely(((comp) & rtlpriv->cfg->mod_params->debug_mask) &&
36 		     ((level) <= rtlpriv->cfg->mod_params->debug_level))) {
37 		pr_info("In process \"%s\" (pid %i): %s\n",
38 			current->comm, current->pid, titlestring);
39 		print_hex_dump_bytes("", DUMP_PREFIX_NONE,
40 				     hexdata, hexdatalen);
41 	}
42 }
43 EXPORT_SYMBOL_GPL(_rtl_dbg_print_data);
44 
45 struct rtl_debugfs_priv {
46 	struct rtl_priv *rtlpriv;
47 	int (*cb_read)(struct seq_file *m, void *v);
48 	ssize_t (*cb_write)(struct file *filp, const char __user *buffer,
49 			    size_t count, loff_t *loff);
50 	u32 cb_data;
51 };
52 
53 static struct dentry *debugfs_topdir;
54 
55 static int rtl_debug_get_common(struct seq_file *m, void *v)
56 {
57 	struct rtl_debugfs_priv *debugfs_priv = m->private;
58 
59 	return debugfs_priv->cb_read(m, v);
60 }
61 
62 static int dl_debug_open_common(struct inode *inode, struct file *file)
63 {
64 	return single_open(file, rtl_debug_get_common, inode->i_private);
65 }
66 
67 static const struct file_operations file_ops_common = {
68 	.open = dl_debug_open_common,
69 	.read = seq_read,
70 	.llseek = seq_lseek,
71 	.release = single_release,
72 };
73 
74 static int rtl_debug_get_mac_page(struct seq_file *m, void *v)
75 {
76 	struct rtl_debugfs_priv *debugfs_priv = m->private;
77 	struct rtl_priv *rtlpriv = debugfs_priv->rtlpriv;
78 	u32 page = debugfs_priv->cb_data;
79 	int i, n;
80 	int max = 0xff;
81 
82 	for (n = 0; n <= max; ) {
83 		seq_printf(m, "\n%8.8x  ", n + page);
84 		for (i = 0; i < 4 && n <= max; i++, n += 4)
85 			seq_printf(m, "%8.8x    ",
86 				   rtl_read_dword(rtlpriv, (page | n)));
87 	}
88 	seq_puts(m, "\n");
89 	return 0;
90 }
91 
92 #define RTL_DEBUG_IMPL_MAC_SERIES(page, addr)			\
93 static struct rtl_debugfs_priv rtl_debug_priv_mac_ ##page = {	\
94 	.cb_read = rtl_debug_get_mac_page,			\
95 	.cb_data = addr,					\
96 }
97 
98 RTL_DEBUG_IMPL_MAC_SERIES(0, 0x0000);
99 RTL_DEBUG_IMPL_MAC_SERIES(1, 0x0100);
100 RTL_DEBUG_IMPL_MAC_SERIES(2, 0x0200);
101 RTL_DEBUG_IMPL_MAC_SERIES(3, 0x0300);
102 RTL_DEBUG_IMPL_MAC_SERIES(4, 0x0400);
103 RTL_DEBUG_IMPL_MAC_SERIES(5, 0x0500);
104 RTL_DEBUG_IMPL_MAC_SERIES(6, 0x0600);
105 RTL_DEBUG_IMPL_MAC_SERIES(7, 0x0700);
106 RTL_DEBUG_IMPL_MAC_SERIES(10, 0x1000);
107 RTL_DEBUG_IMPL_MAC_SERIES(11, 0x1100);
108 RTL_DEBUG_IMPL_MAC_SERIES(12, 0x1200);
109 RTL_DEBUG_IMPL_MAC_SERIES(13, 0x1300);
110 RTL_DEBUG_IMPL_MAC_SERIES(14, 0x1400);
111 RTL_DEBUG_IMPL_MAC_SERIES(15, 0x1500);
112 RTL_DEBUG_IMPL_MAC_SERIES(16, 0x1600);
113 RTL_DEBUG_IMPL_MAC_SERIES(17, 0x1700);
114 
115 static int rtl_debug_get_bb_page(struct seq_file *m, void *v)
116 {
117 	struct rtl_debugfs_priv *debugfs_priv = m->private;
118 	struct rtl_priv *rtlpriv = debugfs_priv->rtlpriv;
119 	struct ieee80211_hw *hw = rtlpriv->hw;
120 	u32 page = debugfs_priv->cb_data;
121 	int i, n;
122 	int max = 0xff;
123 
124 	for (n = 0; n <= max; ) {
125 		seq_printf(m, "\n%8.8x  ", n + page);
126 		for (i = 0; i < 4 && n <= max; i++, n += 4)
127 			seq_printf(m, "%8.8x    ",
128 				   rtl_get_bbreg(hw, (page | n), 0xffffffff));
129 	}
130 	seq_puts(m, "\n");
131 	return 0;
132 }
133 
134 #define RTL_DEBUG_IMPL_BB_SERIES(page, addr)			\
135 static struct rtl_debugfs_priv rtl_debug_priv_bb_ ##page = {	\
136 	.cb_read = rtl_debug_get_bb_page,			\
137 	.cb_data = addr,					\
138 }
139 
140 RTL_DEBUG_IMPL_BB_SERIES(8, 0x0800);
141 RTL_DEBUG_IMPL_BB_SERIES(9, 0x0900);
142 RTL_DEBUG_IMPL_BB_SERIES(a, 0x0a00);
143 RTL_DEBUG_IMPL_BB_SERIES(b, 0x0b00);
144 RTL_DEBUG_IMPL_BB_SERIES(c, 0x0c00);
145 RTL_DEBUG_IMPL_BB_SERIES(d, 0x0d00);
146 RTL_DEBUG_IMPL_BB_SERIES(e, 0x0e00);
147 RTL_DEBUG_IMPL_BB_SERIES(f, 0x0f00);
148 RTL_DEBUG_IMPL_BB_SERIES(18, 0x1800);
149 RTL_DEBUG_IMPL_BB_SERIES(19, 0x1900);
150 RTL_DEBUG_IMPL_BB_SERIES(1a, 0x1a00);
151 RTL_DEBUG_IMPL_BB_SERIES(1b, 0x1b00);
152 RTL_DEBUG_IMPL_BB_SERIES(1c, 0x1c00);
153 RTL_DEBUG_IMPL_BB_SERIES(1d, 0x1d00);
154 RTL_DEBUG_IMPL_BB_SERIES(1e, 0x1e00);
155 RTL_DEBUG_IMPL_BB_SERIES(1f, 0x1f00);
156 
157 static int rtl_debug_get_reg_rf(struct seq_file *m, void *v)
158 {
159 	struct rtl_debugfs_priv *debugfs_priv = m->private;
160 	struct rtl_priv *rtlpriv = debugfs_priv->rtlpriv;
161 	struct ieee80211_hw *hw = rtlpriv->hw;
162 	enum radio_path rfpath = debugfs_priv->cb_data;
163 	int i, n;
164 	int max = 0x40;
165 
166 	if (IS_HARDWARE_TYPE_8822B(rtlpriv))
167 		max = 0xff;
168 
169 	seq_printf(m, "\nPATH(%d)", rfpath);
170 
171 	for (n = 0; n <= max; ) {
172 		seq_printf(m, "\n%8.8x  ", n);
173 		for (i = 0; i < 4 && n <= max; n += 1, i++)
174 			seq_printf(m, "%8.8x    ",
175 				   rtl_get_rfreg(hw, rfpath, n, 0xffffffff));
176 	}
177 	seq_puts(m, "\n");
178 	return 0;
179 }
180 
181 #define RTL_DEBUG_IMPL_RF_SERIES(page, addr)			\
182 static struct rtl_debugfs_priv rtl_debug_priv_rf_ ##page = {	\
183 	.cb_read = rtl_debug_get_reg_rf,			\
184 	.cb_data = addr,					\
185 }
186 
187 RTL_DEBUG_IMPL_RF_SERIES(a, RF90_PATH_A);
188 RTL_DEBUG_IMPL_RF_SERIES(b, RF90_PATH_B);
189 
190 static int rtl_debug_get_cam_register(struct seq_file *m, void *v)
191 {
192 	struct rtl_debugfs_priv *debugfs_priv = m->private;
193 	struct rtl_priv *rtlpriv = debugfs_priv->rtlpriv;
194 	int start = debugfs_priv->cb_data;
195 	u32 target_cmd = 0;
196 	u32 target_val = 0;
197 	u8 entry_i = 0;
198 	u32 ulstatus;
199 	int i = 100, j = 0;
200 	int end = (start + 11 > TOTAL_CAM_ENTRY ? TOTAL_CAM_ENTRY : start + 11);
201 
202 	/* This dump the current register page */
203 	seq_printf(m,
204 		   "\n#################### SECURITY CAM (%d-%d) ##################\n",
205 		   start, end - 1);
206 
207 	for (j = start; j < end; j++) {
208 		seq_printf(m, "\nD:  %2x > ", j);
209 		for (entry_i = 0; entry_i < CAM_CONTENT_COUNT; entry_i++) {
210 			/* polling bit, and No Write enable, and address  */
211 			target_cmd = entry_i + CAM_CONTENT_COUNT * j;
212 			target_cmd = target_cmd | BIT(31);
213 
214 			/* Check polling bit is clear */
215 			while ((i--) >= 0) {
216 				ulstatus =
217 				    rtl_read_dword(rtlpriv,
218 						   rtlpriv->cfg->maps[RWCAM]);
219 				if (ulstatus & BIT(31))
220 					continue;
221 				else
222 					break;
223 			}
224 
225 			rtl_write_dword(rtlpriv, rtlpriv->cfg->maps[RWCAM],
226 					target_cmd);
227 			target_val = rtl_read_dword(rtlpriv,
228 						    rtlpriv->cfg->maps[RCAMO]);
229 			seq_printf(m, "%8.8x ", target_val);
230 		}
231 	}
232 	seq_puts(m, "\n");
233 	return 0;
234 }
235 
236 #define RTL_DEBUG_IMPL_CAM_SERIES(page, addr)			\
237 static struct rtl_debugfs_priv rtl_debug_priv_cam_ ##page = {	\
238 	.cb_read = rtl_debug_get_cam_register,			\
239 	.cb_data = addr,					\
240 }
241 
242 RTL_DEBUG_IMPL_CAM_SERIES(1, 0);
243 RTL_DEBUG_IMPL_CAM_SERIES(2, 11);
244 RTL_DEBUG_IMPL_CAM_SERIES(3, 22);
245 
246 static int rtl_debug_get_btcoex(struct seq_file *m, void *v)
247 {
248 	struct rtl_debugfs_priv *debugfs_priv = m->private;
249 	struct rtl_priv *rtlpriv = debugfs_priv->rtlpriv;
250 
251 	if (rtlpriv->cfg->ops->get_btc_status())
252 		rtlpriv->btcoexist.btc_ops->btc_display_bt_coex_info(rtlpriv,
253 								     m);
254 
255 	seq_puts(m, "\n");
256 
257 	return 0;
258 }
259 
260 static struct rtl_debugfs_priv rtl_debug_priv_btcoex = {
261 	.cb_read = rtl_debug_get_btcoex,
262 	.cb_data = 0,
263 };
264 
265 static ssize_t rtl_debugfs_set_write_reg(struct file *filp,
266 					 const char __user *buffer,
267 					 size_t count, loff_t *loff)
268 {
269 	struct rtl_debugfs_priv *debugfs_priv = filp->private_data;
270 	struct rtl_priv *rtlpriv = debugfs_priv->rtlpriv;
271 	char tmp[32 + 1];
272 	int tmp_len;
273 	u32 addr, val, len;
274 	int num;
275 
276 	if (count < 3)
277 		return -EFAULT;
278 
279 	tmp_len = (count > sizeof(tmp) - 1 ? sizeof(tmp) - 1 : count);
280 
281 	if (copy_from_user(tmp, buffer, tmp_len))
282 		return -EFAULT;
283 
284 	tmp[tmp_len] = '\0';
285 
286 	/* write BB/MAC register */
287 	num = sscanf(tmp, "%x %x %x", &addr, &val, &len);
288 
289 	if (num !=  3)
290 		return -EINVAL;
291 
292 	switch (len) {
293 	case 1:
294 		rtl_write_byte(rtlpriv, addr, (u8)val);
295 		break;
296 	case 2:
297 		rtl_write_word(rtlpriv, addr, (u16)val);
298 		break;
299 	case 4:
300 		rtl_write_dword(rtlpriv, addr, val);
301 		break;
302 	default:
303 		/*printk("error write length=%d", len);*/
304 		break;
305 	}
306 
307 	return count;
308 }
309 
310 static struct rtl_debugfs_priv rtl_debug_priv_write_reg = {
311 	.cb_write = rtl_debugfs_set_write_reg,
312 };
313 
314 static ssize_t rtl_debugfs_set_write_h2c(struct file *filp,
315 					 const char __user *buffer,
316 					 size_t count, loff_t *loff)
317 {
318 	struct rtl_debugfs_priv *debugfs_priv = filp->private_data;
319 	struct rtl_priv *rtlpriv = debugfs_priv->rtlpriv;
320 	struct ieee80211_hw *hw = rtlpriv->hw;
321 	char tmp[32 + 1];
322 	int tmp_len;
323 	u8 h2c_len, h2c_data_packed[8];
324 	int h2c_data[8];	/* idx 0: cmd */
325 	int i;
326 
327 	if (count < 3)
328 		return -EFAULT;
329 
330 	tmp_len = (count > sizeof(tmp) - 1 ? sizeof(tmp) - 1 : count);
331 
332 	if (copy_from_user(tmp, buffer, tmp_len))
333 		return -EFAULT;
334 
335 	tmp[tmp_len] = '\0';
336 
337 	h2c_len = sscanf(tmp, "%X %X %X %X %X %X %X %X",
338 			 &h2c_data[0], &h2c_data[1],
339 			 &h2c_data[2], &h2c_data[3],
340 			 &h2c_data[4], &h2c_data[5],
341 			 &h2c_data[6], &h2c_data[7]);
342 
343 	if (h2c_len == 0)
344 		return -EINVAL;
345 
346 	for (i = 0; i < h2c_len; i++)
347 		h2c_data_packed[i] = (u8)h2c_data[i];
348 
349 	rtlpriv->cfg->ops->fill_h2c_cmd(hw, h2c_data_packed[0],
350 					h2c_len - 1,
351 					&h2c_data_packed[1]);
352 
353 	return count;
354 }
355 
356 static struct rtl_debugfs_priv rtl_debug_priv_write_h2c = {
357 	.cb_write = rtl_debugfs_set_write_h2c,
358 };
359 
360 static ssize_t rtl_debugfs_set_write_rfreg(struct file *filp,
361 					   const char __user *buffer,
362 					    size_t count, loff_t *loff)
363 {
364 	struct rtl_debugfs_priv *debugfs_priv = filp->private_data;
365 	struct rtl_priv *rtlpriv = debugfs_priv->rtlpriv;
366 	struct ieee80211_hw *hw = rtlpriv->hw;
367 	char tmp[32 + 1];
368 	int tmp_len;
369 	int num;
370 	int path;
371 	u32 addr, bitmask, data;
372 
373 	if (count < 3)
374 		return -EFAULT;
375 
376 	tmp_len = (count > sizeof(tmp) - 1 ? sizeof(tmp) - 1 : count);
377 
378 	if (copy_from_user(tmp, buffer, tmp_len))
379 		return -EFAULT;
380 
381 	tmp[tmp_len] = '\0';
382 
383 	num = sscanf(tmp, "%X %X %X %X",
384 		     &path, &addr, &bitmask, &data);
385 
386 	if (num != 4) {
387 		rtl_dbg(rtlpriv, COMP_ERR, DBG_DMESG,
388 			"Format is <path> <addr> <mask> <data>\n");
389 		return -EINVAL;
390 	}
391 
392 	rtl_set_rfreg(hw, path, addr, bitmask, data);
393 
394 	return count;
395 }
396 
397 static struct rtl_debugfs_priv rtl_debug_priv_write_rfreg = {
398 	.cb_write = rtl_debugfs_set_write_rfreg,
399 };
400 
401 static int rtl_debugfs_close(struct inode *inode, struct file *filp)
402 {
403 	return 0;
404 }
405 
406 static ssize_t rtl_debugfs_common_write(struct file *filp,
407 					const char __user *buffer,
408 					size_t count, loff_t *loff)
409 {
410 	struct rtl_debugfs_priv *debugfs_priv = filp->private_data;
411 
412 	return debugfs_priv->cb_write(filp, buffer, count, loff);
413 }
414 
415 static const struct file_operations file_ops_common_write = {
416 	.owner = THIS_MODULE,
417 	.write = rtl_debugfs_common_write,
418 	.open = simple_open,
419 	.release = rtl_debugfs_close,
420 };
421 
422 #define RTL_DEBUGFS_ADD_CORE(name, mode, fopname)			   \
423 	do {								   \
424 		rtl_debug_priv_ ##name.rtlpriv = rtlpriv;		   \
425 		debugfs_create_file(#name, mode, parent,		   \
426 				    &rtl_debug_priv_ ##name,		   \
427 				    &file_ops_ ##fopname);		   \
428 	} while (0)
429 
430 #define RTL_DEBUGFS_ADD(name)						   \
431 		RTL_DEBUGFS_ADD_CORE(name, S_IFREG | 0444, common)
432 #define RTL_DEBUGFS_ADD_W(name)						   \
433 		RTL_DEBUGFS_ADD_CORE(name, S_IFREG | 0222, common_write)
434 
435 void rtl_debug_add_one(struct ieee80211_hw *hw)
436 {
437 	struct rtl_priv *rtlpriv = rtl_priv(hw);
438 	struct rtl_efuse *rtlefuse = rtl_efuse(rtl_priv(hw));
439 	struct dentry *parent;
440 
441 	snprintf(rtlpriv->dbg.debugfs_name, 18, "%pMF", rtlefuse->dev_addr);
442 
443 	rtlpriv->dbg.debugfs_dir =
444 		debugfs_create_dir(rtlpriv->dbg.debugfs_name, debugfs_topdir);
445 
446 	parent = rtlpriv->dbg.debugfs_dir;
447 
448 	RTL_DEBUGFS_ADD(mac_0);
449 	RTL_DEBUGFS_ADD(mac_1);
450 	RTL_DEBUGFS_ADD(mac_2);
451 	RTL_DEBUGFS_ADD(mac_3);
452 	RTL_DEBUGFS_ADD(mac_4);
453 	RTL_DEBUGFS_ADD(mac_5);
454 	RTL_DEBUGFS_ADD(mac_6);
455 	RTL_DEBUGFS_ADD(mac_7);
456 	RTL_DEBUGFS_ADD(bb_8);
457 	RTL_DEBUGFS_ADD(bb_9);
458 	RTL_DEBUGFS_ADD(bb_a);
459 	RTL_DEBUGFS_ADD(bb_b);
460 	RTL_DEBUGFS_ADD(bb_c);
461 	RTL_DEBUGFS_ADD(bb_d);
462 	RTL_DEBUGFS_ADD(bb_e);
463 	RTL_DEBUGFS_ADD(bb_f);
464 	RTL_DEBUGFS_ADD(mac_10);
465 	RTL_DEBUGFS_ADD(mac_11);
466 	RTL_DEBUGFS_ADD(mac_12);
467 	RTL_DEBUGFS_ADD(mac_13);
468 	RTL_DEBUGFS_ADD(mac_14);
469 	RTL_DEBUGFS_ADD(mac_15);
470 	RTL_DEBUGFS_ADD(mac_16);
471 	RTL_DEBUGFS_ADD(mac_17);
472 	RTL_DEBUGFS_ADD(bb_18);
473 	RTL_DEBUGFS_ADD(bb_19);
474 	RTL_DEBUGFS_ADD(bb_1a);
475 	RTL_DEBUGFS_ADD(bb_1b);
476 	RTL_DEBUGFS_ADD(bb_1c);
477 	RTL_DEBUGFS_ADD(bb_1d);
478 	RTL_DEBUGFS_ADD(bb_1e);
479 	RTL_DEBUGFS_ADD(bb_1f);
480 	RTL_DEBUGFS_ADD(rf_a);
481 	RTL_DEBUGFS_ADD(rf_b);
482 
483 	RTL_DEBUGFS_ADD(cam_1);
484 	RTL_DEBUGFS_ADD(cam_2);
485 	RTL_DEBUGFS_ADD(cam_3);
486 
487 	RTL_DEBUGFS_ADD(btcoex);
488 
489 	RTL_DEBUGFS_ADD_W(write_reg);
490 	RTL_DEBUGFS_ADD_W(write_h2c);
491 	RTL_DEBUGFS_ADD_W(write_rfreg);
492 }
493 EXPORT_SYMBOL_GPL(rtl_debug_add_one);
494 
495 void rtl_debug_remove_one(struct ieee80211_hw *hw)
496 {
497 	struct rtl_priv *rtlpriv = rtl_priv(hw);
498 
499 	debugfs_remove_recursive(rtlpriv->dbg.debugfs_dir);
500 	rtlpriv->dbg.debugfs_dir = NULL;
501 }
502 EXPORT_SYMBOL_GPL(rtl_debug_remove_one);
503 
504 void rtl_debugfs_add_topdir(void)
505 {
506 	debugfs_topdir = debugfs_create_dir("rtlwifi", NULL);
507 }
508 
509 void rtl_debugfs_remove_topdir(void)
510 {
511 	debugfs_remove_recursive(debugfs_topdir);
512 }
513 
514 #endif
515