1 // SPDX-License-Identifier: GPL-2.0
2 /******************************************************************************
3  *
4  * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
5  *
6  ******************************************************************************/
7 
8 #include <drv_types.h>
9 #include <rtw_debug.h>
10 #include <rtl8723b_hal.h>
11 
12 static u8 rtw_sdio_wait_enough_TxOQT_space(struct adapter *padapter, u8 agg_num)
13 {
14 	u32 n = 0;
15 	struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
16 
17 	while (pHalData->SdioTxOQTFreeSpace < agg_num) {
18 		if (
19 			(padapter->bSurpriseRemoved) ||
20 			(padapter->bDriverStopped)
21 		)
22 			return false;
23 
24 		HalQueryTxOQTBufferStatus8723BSdio(padapter);
25 
26 		if ((++n % 60) == 0) {
27 			msleep(1);
28 			/* yield(); */
29 		}
30 	}
31 
32 	pHalData->SdioTxOQTFreeSpace -= agg_num;
33 
34 	return true;
35 }
36 
37 static s32 rtl8723_dequeue_writeport(struct adapter *padapter)
38 {
39 	struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
40 	struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
41 	struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(padapter);
42 	struct xmit_buf *pxmitbuf;
43 	struct adapter *pri_padapter = padapter;
44 	s32 ret = 0;
45 	u8 PageIdx = 0;
46 	u32 deviceId;
47 	u8 bUpdatePageNum = false;
48 
49 	ret = ret || check_fwstate(pmlmepriv, _FW_UNDER_SURVEY);
50 
51 	if (ret)
52 		pxmitbuf = dequeue_pending_xmitbuf_under_survey(pxmitpriv);
53 	else
54 		pxmitbuf = dequeue_pending_xmitbuf(pxmitpriv);
55 
56 	if (!pxmitbuf)
57 		return true;
58 
59 	deviceId = ffaddr2deviceId(pdvobjpriv, pxmitbuf->ff_hwaddr);
60 
61 	/*  translate fifo addr to queue index */
62 	switch (deviceId) {
63 	case WLAN_TX_HIQ_DEVICE_ID:
64 		PageIdx = HI_QUEUE_IDX;
65 		break;
66 
67 	case WLAN_TX_MIQ_DEVICE_ID:
68 		PageIdx = MID_QUEUE_IDX;
69 		break;
70 
71 	case WLAN_TX_LOQ_DEVICE_ID:
72 		PageIdx = LOW_QUEUE_IDX;
73 		break;
74 	}
75 
76 query_free_page:
77 	/*  check if hardware tx fifo page is enough */
78 	if (!rtw_hal_sdio_query_tx_freepage(pri_padapter, PageIdx, pxmitbuf->pg_num)) {
79 		if (!bUpdatePageNum) {
80 			/*  Total number of page is NOT available, so update current FIFO status */
81 			HalQueryTxBufferStatus8723BSdio(padapter);
82 			bUpdatePageNum = true;
83 			goto query_free_page;
84 		} else {
85 			bUpdatePageNum = false;
86 			enqueue_pending_xmitbuf_to_head(pxmitpriv, pxmitbuf);
87 			return true;
88 		}
89 	}
90 
91 	if (
92 		(padapter->bSurpriseRemoved) ||
93 		(padapter->bDriverStopped)
94 	)
95 		goto free_xmitbuf;
96 
97 	if (rtw_sdio_wait_enough_TxOQT_space(padapter, pxmitbuf->agg_num) == false)
98 		goto free_xmitbuf;
99 
100 	traffic_check_for_leave_lps(padapter, true, pxmitbuf->agg_num);
101 
102 	rtw_write_port(padapter, deviceId, pxmitbuf->len, (u8 *)pxmitbuf);
103 
104 	rtw_hal_sdio_update_tx_freepage(pri_padapter, PageIdx, pxmitbuf->pg_num);
105 
106 free_xmitbuf:
107 	/* rtw_free_xmitframe(pxmitpriv, pframe); */
108 	/* pxmitbuf->priv_data = NULL; */
109 	rtw_free_xmitbuf(pxmitpriv, pxmitbuf);
110 
111 	return _FAIL;
112 }
113 
114 /*
115  * Description
116  *Transmit xmitbuf to hardware tx fifo
117  *
118  * Return
119  *_SUCCESS	ok
120  *_FAIL		something error
121  */
122 s32 rtl8723bs_xmit_buf_handler(struct adapter *padapter)
123 {
124 	struct xmit_priv *pxmitpriv;
125 	u8 queue_empty, queue_pending;
126 	s32 ret;
127 
128 
129 	pxmitpriv = &padapter->xmitpriv;
130 
131 	if (wait_for_completion_interruptible(&pxmitpriv->xmit_comp)) {
132 		netdev_emerg(padapter->pnetdev,
133 			     "%s: down SdioXmitBufSema fail!\n", __func__);
134 		return _FAIL;
135 	}
136 
137 	ret = (padapter->bDriverStopped) || (padapter->bSurpriseRemoved);
138 	if (ret)
139 		return _FAIL;
140 
141 	queue_pending = check_pending_xmitbuf(pxmitpriv);
142 
143 	if (!queue_pending)
144 		return _SUCCESS;
145 
146 	ret = rtw_register_tx_alive(padapter);
147 	if (ret != _SUCCESS) {
148 		return _SUCCESS;
149 	}
150 
151 	do {
152 		queue_empty = rtl8723_dequeue_writeport(padapter);
153 /* 	dump secondary adapter xmitbuf */
154 	} while (!queue_empty);
155 
156 	rtw_unregister_tx_alive(padapter);
157 
158 	return _SUCCESS;
159 }
160 
161 /*
162  * Description:
163  *Aggregation packets and send to hardware
164  *
165  * Return:
166  *0	Success
167  *-1	Hardware resource(TX FIFO) not ready
168  *-2	Software resource(xmitbuf) not ready
169  */
170 static s32 xmit_xmitframes(struct adapter *padapter, struct xmit_priv *pxmitpriv)
171 {
172 	s32 err, ret;
173 	u32 k = 0;
174 	struct hw_xmit *hwxmits, *phwxmit;
175 	u8 idx, hwentry;
176 	struct tx_servq *ptxservq;
177 	struct list_head *sta_plist, *sta_phead, *frame_plist, *frame_phead, *tmp;
178 	struct xmit_frame *pxmitframe;
179 	struct __queue *pframe_queue;
180 	struct xmit_buf *pxmitbuf;
181 	u32 txlen, max_xmit_len;
182 	u8 txdesc_size = TXDESC_SIZE;
183 	int inx[4];
184 
185 	err = 0;
186 	hwxmits = pxmitpriv->hwxmits;
187 	hwentry = pxmitpriv->hwxmit_entry;
188 	ptxservq = NULL;
189 	pxmitframe = NULL;
190 	pframe_queue = NULL;
191 	pxmitbuf = NULL;
192 
193 	if (padapter->registrypriv.wifi_spec == 1) {
194 		for (idx = 0; idx < 4; idx++)
195 			inx[idx] = pxmitpriv->wmm_para_seq[idx];
196 	} else {
197 		inx[0] = 0;
198 		inx[1] = 1;
199 		inx[2] = 2;
200 		inx[3] = 3;
201 	}
202 
203 	/*  0(VO), 1(VI), 2(BE), 3(BK) */
204 	for (idx = 0; idx < hwentry; idx++) {
205 		phwxmit = hwxmits + inx[idx];
206 
207 		if (
208 			(check_pending_xmitbuf(pxmitpriv)) &&
209 			(padapter->mlmepriv.LinkDetectInfo.bHigherBusyTxTraffic)
210 		) {
211 			if ((phwxmit->accnt > 0) && (phwxmit->accnt < 5)) {
212 				err = -2;
213 				break;
214 			}
215 		}
216 
217 		max_xmit_len = rtw_hal_get_sdio_tx_max_length(padapter, inx[idx]);
218 
219 		spin_lock_bh(&pxmitpriv->lock);
220 
221 		sta_phead = get_list_head(phwxmit->sta_queue);
222 		/* because stop_sta_xmit may delete sta_plist at any time */
223 		/* so we should add lock here, or while loop can not exit */
224 		list_for_each_safe(sta_plist, tmp, sta_phead) {
225 			ptxservq = list_entry(sta_plist, struct tx_servq,
226 					      tx_pending);
227 
228 			pframe_queue = &ptxservq->sta_pending;
229 
230 			frame_phead = get_list_head(pframe_queue);
231 
232 			while (list_empty(frame_phead) == false) {
233 				frame_plist = get_next(frame_phead);
234 				pxmitframe = container_of(frame_plist, struct xmit_frame, list);
235 
236 				/*  check xmit_buf size enough or not */
237 				txlen = txdesc_size + rtw_wlan_pkt_size(pxmitframe);
238 				if (!pxmitbuf ||
239 					((_RND(pxmitbuf->len, 8) + txlen) > max_xmit_len) ||
240 					(k >= (rtw_hal_sdio_max_txoqt_free_space(padapter) - 1))
241 				) {
242 					if (pxmitbuf) {
243 						/* pxmitbuf->priv_data will be NULL, and will crash here */
244 						if (pxmitbuf->len > 0 &&
245 						    pxmitbuf->priv_data) {
246 							struct xmit_frame *pframe;
247 							pframe = (struct xmit_frame *)pxmitbuf->priv_data;
248 							pframe->agg_num = k;
249 							pxmitbuf->agg_num = k;
250 							rtl8723b_update_txdesc(pframe, pframe->buf_addr);
251 							rtw_free_xmitframe(pxmitpriv, pframe);
252 							pxmitbuf->priv_data = NULL;
253 							enqueue_pending_xmitbuf(pxmitpriv, pxmitbuf);
254 							/* can not yield under lock */
255 							/* yield(); */
256 						} else
257 							rtw_free_xmitbuf(pxmitpriv, pxmitbuf);
258 					}
259 
260 					pxmitbuf = rtw_alloc_xmitbuf(pxmitpriv);
261 					if (!pxmitbuf) {
262 #ifdef DBG_XMIT_BUF
263 						netdev_err(padapter->pnetdev,
264 							   "%s: xmit_buf is not enough!\n",
265 							   __func__);
266 #endif
267 						err = -2;
268 						complete(&(pxmitpriv->xmit_comp));
269 						break;
270 					}
271 					k = 0;
272 				}
273 
274 				/*  ok to send, remove frame from queue */
275 				if (check_fwstate(&padapter->mlmepriv, WIFI_AP_STATE) == true)
276 					if (
277 						(pxmitframe->attrib.psta->state & WIFI_SLEEP_STATE) &&
278 						(pxmitframe->attrib.triggered == 0)
279 					)
280 						break;
281 
282 				list_del_init(&pxmitframe->list);
283 				ptxservq->qcnt--;
284 				phwxmit->accnt--;
285 
286 				if (k == 0) {
287 					pxmitbuf->ff_hwaddr = rtw_get_ff_hwaddr(pxmitframe);
288 					pxmitbuf->priv_data = (u8 *)pxmitframe;
289 				}
290 
291 				/*  coalesce the xmitframe to xmitbuf */
292 				pxmitframe->pxmitbuf = pxmitbuf;
293 				pxmitframe->buf_addr = pxmitbuf->ptail;
294 
295 				ret = rtw_xmitframe_coalesce(padapter, pxmitframe->pkt, pxmitframe);
296 				if (ret == _FAIL) {
297 					netdev_err(padapter->pnetdev,
298 						   "%s: coalesce FAIL!",
299 						   __func__);
300 					/*  Todo: error handler */
301 				} else {
302 					k++;
303 					if (k != 1)
304 						rtl8723b_update_txdesc(pxmitframe, pxmitframe->buf_addr);
305 					rtw_count_tx_stats(padapter, pxmitframe, pxmitframe->attrib.last_txcmdsz);
306 
307 					txlen = txdesc_size + pxmitframe->attrib.last_txcmdsz;
308 					pxmitframe->pg_num = (txlen + 127) / 128;
309 					pxmitbuf->pg_num += (txlen + 127) / 128;
310 					pxmitbuf->ptail += _RND(txlen, 8); /*  round to 8 bytes alignment */
311 					pxmitbuf->len = _RND(pxmitbuf->len, 8) + txlen;
312 				}
313 
314 				if (k != 1)
315 					rtw_free_xmitframe(pxmitpriv, pxmitframe);
316 				pxmitframe = NULL;
317 			}
318 
319 			if (list_empty(&pframe_queue->queue))
320 				list_del_init(&ptxservq->tx_pending);
321 
322 			if (err)
323 				break;
324 		}
325 		spin_unlock_bh(&pxmitpriv->lock);
326 
327 		/*  dump xmit_buf to hw tx fifo */
328 		if (pxmitbuf) {
329 			if (pxmitbuf->len > 0) {
330 				struct xmit_frame *pframe;
331 				pframe = (struct xmit_frame *)pxmitbuf->priv_data;
332 				pframe->agg_num = k;
333 				pxmitbuf->agg_num = k;
334 				rtl8723b_update_txdesc(pframe, pframe->buf_addr);
335 				rtw_free_xmitframe(pxmitpriv, pframe);
336 				pxmitbuf->priv_data = NULL;
337 				enqueue_pending_xmitbuf(pxmitpriv, pxmitbuf);
338 				yield();
339 			} else
340 				rtw_free_xmitbuf(pxmitpriv, pxmitbuf);
341 			pxmitbuf = NULL;
342 		}
343 
344 		if (err)
345 			break;
346 	}
347 
348 	return err;
349 }
350 
351 /*
352  * Description
353  *Transmit xmitframe from queue
354  *
355  * Return
356  *_SUCCESS	ok
357  *_FAIL		something error
358  */
359 static s32 rtl8723bs_xmit_handler(struct adapter *padapter)
360 {
361 	struct xmit_priv *pxmitpriv;
362 	s32 ret;
363 
364 
365 	pxmitpriv = &padapter->xmitpriv;
366 
367 	if (wait_for_completion_interruptible(&pxmitpriv->SdioXmitStart)) {
368 		netdev_emerg(padapter->pnetdev, "%s: SdioXmitStart fail!\n",
369 			     __func__);
370 		return _FAIL;
371 	}
372 
373 next:
374 	if (
375 		(padapter->bDriverStopped) ||
376 		(padapter->bSurpriseRemoved)
377 	)
378 		return _FAIL;
379 
380 	spin_lock_bh(&pxmitpriv->lock);
381 	ret = rtw_txframes_pending(padapter);
382 	spin_unlock_bh(&pxmitpriv->lock);
383 	if (ret == 0) {
384 		return _SUCCESS;
385 	}
386 
387 	/*  dequeue frame and write to hardware */
388 
389 	ret = xmit_xmitframes(padapter, pxmitpriv);
390 	if (ret == -2) {
391 		/* here sleep 1ms will cause big TP loss of TX */
392 		/* from 50+ to 40+ */
393 		if (padapter->registrypriv.wifi_spec)
394 			msleep(1);
395 		else
396 			yield();
397 		goto next;
398 	}
399 
400 	spin_lock_bh(&pxmitpriv->lock);
401 	ret = rtw_txframes_pending(padapter);
402 	spin_unlock_bh(&pxmitpriv->lock);
403 	if (ret == 1) {
404 		goto next;
405 	}
406 
407 	return _SUCCESS;
408 }
409 
410 int rtl8723bs_xmit_thread(void *context)
411 {
412 	s32 ret;
413 	struct adapter *padapter;
414 	struct xmit_priv *pxmitpriv;
415 	u8 thread_name[20];
416 
417 	ret = _SUCCESS;
418 	padapter = context;
419 	pxmitpriv = &padapter->xmitpriv;
420 
421 	rtw_sprintf(thread_name, 20, "RTWHALXT-%s", ADPT_ARG(padapter));
422 	thread_enter(thread_name);
423 
424 	do {
425 		ret = rtl8723bs_xmit_handler(padapter);
426 		if (signal_pending(current)) {
427 			flush_signals(current);
428 		}
429 	} while (_SUCCESS == ret);
430 
431 	complete(&pxmitpriv->SdioXmitTerminate);
432 
433 	return 0;
434 }
435 
436 s32 rtl8723bs_mgnt_xmit(
437 	struct adapter *padapter, struct xmit_frame *pmgntframe
438 )
439 {
440 	s32 ret = _SUCCESS;
441 	struct pkt_attrib *pattrib;
442 	struct xmit_buf *pxmitbuf;
443 	struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
444 	struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(padapter);
445 	u8 *pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
446 	u8 txdesc_size = TXDESC_SIZE;
447 
448 	pattrib = &pmgntframe->attrib;
449 	pxmitbuf = pmgntframe->pxmitbuf;
450 
451 	rtl8723b_update_txdesc(pmgntframe, pmgntframe->buf_addr);
452 
453 	pxmitbuf->len = txdesc_size + pattrib->last_txcmdsz;
454 	pxmitbuf->pg_num = (pxmitbuf->len + 127) / 128; /*  128 is tx page size */
455 	pxmitbuf->ptail = pmgntframe->buf_addr + pxmitbuf->len;
456 	pxmitbuf->ff_hwaddr = rtw_get_ff_hwaddr(pmgntframe);
457 
458 	rtw_count_tx_stats(padapter, pmgntframe, pattrib->last_txcmdsz);
459 
460 	rtw_free_xmitframe(pxmitpriv, pmgntframe);
461 
462 	pxmitbuf->priv_data = NULL;
463 
464 	if (GetFrameSubType(pframe) == WIFI_BEACON) { /* dump beacon directly */
465 		ret = rtw_write_port(padapter, pdvobjpriv->Queue2Pipe[pxmitbuf->ff_hwaddr], pxmitbuf->len, (u8 *)pxmitbuf);
466 		if (ret != _SUCCESS)
467 			rtw_sctx_done_err(&pxmitbuf->sctx, RTW_SCTX_DONE_WRITE_PORT_ERR);
468 
469 		rtw_free_xmitbuf(pxmitpriv, pxmitbuf);
470 	} else
471 		enqueue_pending_xmitbuf(pxmitpriv, pxmitbuf);
472 
473 	return ret;
474 }
475 
476 /*
477  * Description:
478  *Handle xmitframe(packet) come from rtw_xmit()
479  *
480  * Return:
481  *true	dump packet directly ok
482  *false	enqueue, temporary can't transmit packets to hardware
483  */
484 s32 rtl8723bs_hal_xmit(
485 	struct adapter *padapter, struct xmit_frame *pxmitframe
486 )
487 {
488 	struct xmit_priv *pxmitpriv;
489 	s32 err;
490 
491 
492 	pxmitframe->attrib.qsel = pxmitframe->attrib.priority;
493 	pxmitpriv = &padapter->xmitpriv;
494 
495 	if (
496 		(pxmitframe->frame_tag == DATA_FRAMETAG) &&
497 		(pxmitframe->attrib.ether_type != 0x0806) &&
498 		(pxmitframe->attrib.ether_type != 0x888e) &&
499 		(pxmitframe->attrib.dhcp_pkt != 1)
500 	) {
501 		if (padapter->mlmepriv.LinkDetectInfo.bBusyTraffic)
502 			rtw_issue_addbareq_cmd(padapter, pxmitframe);
503 	}
504 
505 	spin_lock_bh(&pxmitpriv->lock);
506 	err = rtw_xmitframe_enqueue(padapter, pxmitframe);
507 	spin_unlock_bh(&pxmitpriv->lock);
508 	if (err != _SUCCESS) {
509 		rtw_free_xmitframe(pxmitpriv, pxmitframe);
510 
511 		pxmitpriv->tx_drop++;
512 		return true;
513 	}
514 
515 	complete(&pxmitpriv->SdioXmitStart);
516 
517 	return false;
518 }
519 
520 s32	rtl8723bs_hal_xmitframe_enqueue(
521 	struct adapter *padapter, struct xmit_frame *pxmitframe
522 )
523 {
524 	struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
525 	s32 err;
526 
527 	err = rtw_xmitframe_enqueue(padapter, pxmitframe);
528 	if (err != _SUCCESS) {
529 		rtw_free_xmitframe(pxmitpriv, pxmitframe);
530 
531 		pxmitpriv->tx_drop++;
532 	} else {
533 		complete(&pxmitpriv->SdioXmitStart);
534 	}
535 
536 	return err;
537 
538 }
539 
540 /*
541  * Return
542  *_SUCCESS	start thread ok
543  *_FAIL		start thread fail
544  *
545  */
546 s32 rtl8723bs_init_xmit_priv(struct adapter *padapter)
547 {
548 	struct xmit_priv *xmitpriv = &padapter->xmitpriv;
549 	struct hal_com_data *phal;
550 
551 
552 	phal = GET_HAL_DATA(padapter);
553 
554 	spin_lock_init(&phal->SdioTxFIFOFreePageLock);
555 	init_completion(&xmitpriv->SdioXmitStart);
556 	init_completion(&xmitpriv->SdioXmitTerminate);
557 
558 	return _SUCCESS;
559 }
560 
561 void rtl8723bs_free_xmit_priv(struct adapter *padapter)
562 {
563 	struct xmit_priv *pxmitpriv;
564 	struct xmit_buf *pxmitbuf;
565 	struct __queue *pqueue;
566 	struct list_head *plist, *phead;
567 	struct list_head tmplist;
568 
569 
570 	pxmitpriv = &padapter->xmitpriv;
571 	pqueue = &pxmitpriv->pending_xmitbuf_queue;
572 	phead = get_list_head(pqueue);
573 	INIT_LIST_HEAD(&tmplist);
574 
575 	spin_lock_bh(&pqueue->lock);
576 	if (!list_empty(&pqueue->queue)) {
577 		/*  Insert tmplist to end of queue, and delete phead */
578 		/*  then tmplist become head of queue. */
579 		list_add_tail(&tmplist, phead);
580 		list_del_init(phead);
581 	}
582 	spin_unlock_bh(&pqueue->lock);
583 
584 	phead = &tmplist;
585 	while (list_empty(phead) == false) {
586 		plist = get_next(phead);
587 		list_del_init(plist);
588 
589 		pxmitbuf = container_of(plist, struct xmit_buf, list);
590 		rtw_free_xmitframe(pxmitpriv, (struct xmit_frame *)pxmitbuf->priv_data);
591 		pxmitbuf->priv_data = NULL;
592 		rtw_free_xmitbuf(pxmitpriv, pxmitbuf);
593 	}
594 }
595