xref: /linux/drivers/net/wwan/t7xx/t7xx_port_proxy.c (revision 6d9b262afe0ec1d6e0ef99321ca9d6b921310471)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright (c) 2021, MediaTek Inc.
4  * Copyright (c) 2021-2022, Intel Corporation.
5  *
6  * Authors:
7  *  Amir Hanania <amir.hanania@intel.com>
8  *  Haijun Liu <haijun.liu@mediatek.com>
9  *  Moises Veleta <moises.veleta@intel.com>
10  *  Ricardo Martinez <ricardo.martinez@linux.intel.com>
11  *
12  * Contributors:
13  *  Andy Shevchenko <andriy.shevchenko@linux.intel.com>
14  *  Chandrashekar Devegowda <chandrashekar.devegowda@intel.com>
15  *  Chiranjeevi Rapolu <chiranjeevi.rapolu@intel.com>
16  *  Eliot Lee <eliot.lee@intel.com>
17  *  Sreehari Kancharla <sreehari.kancharla@intel.com>
18  */
19 
20 #include <linux/bits.h>
21 #include <linux/bitfield.h>
22 #include <linux/device.h>
23 #include <linux/gfp.h>
24 #include <linux/kernel.h>
25 #include <linux/kthread.h>
26 #include <linux/list.h>
27 #include <linux/mutex.h>
28 #include <linux/netdevice.h>
29 #include <linux/skbuff.h>
30 #include <linux/spinlock.h>
31 #include <linux/wait.h>
32 #include <linux/wwan.h>
33 
34 #include "t7xx_hif_cldma.h"
35 #include "t7xx_modem_ops.h"
36 #include "t7xx_port.h"
37 #include "t7xx_port_proxy.h"
38 #include "t7xx_state_monitor.h"
39 
40 #define Q_IDX_CTRL			0
41 #define Q_IDX_MBIM			2
42 #define Q_IDX_AT_CMD			5
43 
44 #define INVALID_SEQ_NUM			GENMASK(15, 0)
45 
46 #define for_each_proxy_port(i, p, proxy)	\
47 	for (i = 0, (p) = &(proxy)->ports[i];	\
48 	     i < (proxy)->port_count;		\
49 	     i++, (p) = &(proxy)->ports[i])
50 
51 #define T7XX_MAX_POSSIBLE_PORTS_NUM	\
52 	(max(ARRAY_SIZE(t7xx_port_conf), ARRAY_SIZE(t7xx_early_port_conf)))
53 
54 static const struct t7xx_port_conf t7xx_port_conf[] = {
55 	{
56 		.tx_ch = PORT_CH_UART2_TX,
57 		.rx_ch = PORT_CH_UART2_RX,
58 		.txq_index = Q_IDX_AT_CMD,
59 		.rxq_index = Q_IDX_AT_CMD,
60 		.txq_exp_index = 0xff,
61 		.rxq_exp_index = 0xff,
62 		.path_id = CLDMA_ID_MD,
63 		.ops = &wwan_sub_port_ops,
64 		.name = "AT",
65 		.port_type = WWAN_PORT_AT,
66 	}, {
67 		.tx_ch = PORT_CH_MBIM_TX,
68 		.rx_ch = PORT_CH_MBIM_RX,
69 		.txq_index = Q_IDX_MBIM,
70 		.rxq_index = Q_IDX_MBIM,
71 		.path_id = CLDMA_ID_MD,
72 		.ops = &wwan_sub_port_ops,
73 		.name = "MBIM",
74 		.port_type = WWAN_PORT_MBIM,
75 	}, {
76 #ifdef CONFIG_WWAN_DEBUGFS
77 		.tx_ch = PORT_CH_MD_LOG_TX,
78 		.rx_ch = PORT_CH_MD_LOG_RX,
79 		.txq_index = 7,
80 		.rxq_index = 7,
81 		.txq_exp_index = 7,
82 		.rxq_exp_index = 7,
83 		.path_id = CLDMA_ID_MD,
84 		.ops = &t7xx_trace_port_ops,
85 		.name = "mdlog",
86 	}, {
87 #endif
88 		.tx_ch = PORT_CH_CONTROL_TX,
89 		.rx_ch = PORT_CH_CONTROL_RX,
90 		.txq_index = Q_IDX_CTRL,
91 		.rxq_index = Q_IDX_CTRL,
92 		.path_id = CLDMA_ID_MD,
93 		.ops = &ctl_port_ops,
94 		.name = "t7xx_ctrl",
95 	}, {
96 		.tx_ch = PORT_CH_AP_CONTROL_TX,
97 		.rx_ch = PORT_CH_AP_CONTROL_RX,
98 		.txq_index = Q_IDX_CTRL,
99 		.rxq_index = Q_IDX_CTRL,
100 		.path_id = CLDMA_ID_AP,
101 		.ops = &ctl_port_ops,
102 		.name = "t7xx_ap_ctrl",
103 	},
104 };
105 
106 static const struct t7xx_port_conf t7xx_early_port_conf[] = {
107 	{
108 		.tx_ch = PORT_CH_UNIMPORTANT,
109 		.rx_ch = PORT_CH_UNIMPORTANT,
110 		.txq_index = CLDMA_Q_IDX_DUMP,
111 		.rxq_index = CLDMA_Q_IDX_DUMP,
112 		.txq_exp_index = CLDMA_Q_IDX_DUMP,
113 		.rxq_exp_index = CLDMA_Q_IDX_DUMP,
114 		.path_id = CLDMA_ID_AP,
115 		.ops = &wwan_sub_port_ops,
116 		.name = "fastboot",
117 		.port_type = WWAN_PORT_FASTBOOT,
118 	},
119 };
120 
121 static struct t7xx_port *t7xx_proxy_get_port_by_ch(struct port_proxy *port_prox, enum port_ch ch)
122 {
123 	const struct t7xx_port_conf *port_conf;
124 	struct t7xx_port *port;
125 	int i;
126 
127 	for_each_proxy_port(i, port, port_prox) {
128 		port_conf = port->port_conf;
129 		if (port_conf->rx_ch == ch || port_conf->tx_ch == ch)
130 			return port;
131 	}
132 
133 	return NULL;
134 }
135 
136 static u16 t7xx_port_next_rx_seq_num(struct t7xx_port *port, struct ccci_header *ccci_h)
137 {
138 	u32 status = le32_to_cpu(ccci_h->status);
139 	u16 seq_num, next_seq_num;
140 	bool assert_bit;
141 
142 	seq_num = FIELD_GET(CCCI_H_SEQ_FLD, status);
143 	next_seq_num = (seq_num + 1) & FIELD_MAX(CCCI_H_SEQ_FLD);
144 	assert_bit = status & CCCI_H_AST_BIT;
145 	if (!assert_bit || port->seq_nums[MTK_RX] == INVALID_SEQ_NUM)
146 		return next_seq_num;
147 
148 	if (seq_num != port->seq_nums[MTK_RX])
149 		dev_warn_ratelimited(port->dev,
150 				     "seq num out-of-order %u != %u (header %X, len %X)\n",
151 				     seq_num, port->seq_nums[MTK_RX],
152 				     le32_to_cpu(ccci_h->packet_header),
153 				     le32_to_cpu(ccci_h->packet_len));
154 
155 	return next_seq_num;
156 }
157 
158 void t7xx_port_proxy_reset(struct port_proxy *port_prox)
159 {
160 	struct t7xx_port *port;
161 	int i;
162 
163 	for_each_proxy_port(i, port, port_prox) {
164 		port->seq_nums[MTK_RX] = INVALID_SEQ_NUM;
165 		port->seq_nums[MTK_TX] = 0;
166 	}
167 }
168 
169 static int t7xx_port_get_queue_no(struct t7xx_port *port)
170 {
171 	const struct t7xx_port_conf *port_conf = port->port_conf;
172 	struct t7xx_fsm_ctl *ctl = port->t7xx_dev->md->fsm_ctl;
173 
174 	return t7xx_fsm_get_md_state(ctl) == MD_STATE_EXCEPTION ?
175 		port_conf->txq_exp_index : port_conf->txq_index;
176 }
177 
178 static void t7xx_port_struct_init(struct t7xx_port *port)
179 {
180 	INIT_LIST_HEAD(&port->entry);
181 	INIT_LIST_HEAD(&port->queue_entry);
182 	skb_queue_head_init(&port->rx_skb_list);
183 	init_waitqueue_head(&port->rx_wq);
184 	port->seq_nums[MTK_RX] = INVALID_SEQ_NUM;
185 	port->seq_nums[MTK_TX] = 0;
186 	atomic_set(&port->usage_cnt, 0);
187 }
188 
189 struct sk_buff *t7xx_port_alloc_skb(int payload)
190 {
191 	struct sk_buff *skb = __dev_alloc_skb(payload + sizeof(struct ccci_header), GFP_KERNEL);
192 
193 	if (skb)
194 		skb_reserve(skb, sizeof(struct ccci_header));
195 
196 	return skb;
197 }
198 
199 struct sk_buff *t7xx_ctrl_alloc_skb(int payload)
200 {
201 	struct sk_buff *skb = t7xx_port_alloc_skb(payload + sizeof(struct ctrl_msg_header));
202 
203 	if (skb)
204 		skb_reserve(skb, sizeof(struct ctrl_msg_header));
205 
206 	return skb;
207 }
208 
209 /**
210  * t7xx_port_enqueue_skb() - Enqueue the received skb into the port's rx_skb_list.
211  * @port: port context.
212  * @skb: received skb.
213  *
214  * Return:
215  * * 0		- Success.
216  * * -ENOBUFS	- Not enough buffer space. Caller will try again later, skb is not consumed.
217  */
218 int t7xx_port_enqueue_skb(struct t7xx_port *port, struct sk_buff *skb)
219 {
220 	unsigned long flags;
221 
222 	spin_lock_irqsave(&port->rx_wq.lock, flags);
223 	if (port->rx_skb_list.qlen >= port->rx_length_th) {
224 		spin_unlock_irqrestore(&port->rx_wq.lock, flags);
225 
226 		return -ENOBUFS;
227 	}
228 	__skb_queue_tail(&port->rx_skb_list, skb);
229 	spin_unlock_irqrestore(&port->rx_wq.lock, flags);
230 
231 	wake_up_all(&port->rx_wq);
232 	return 0;
233 }
234 
235 int t7xx_get_port_mtu(struct t7xx_port *port)
236 {
237 	enum cldma_id path_id = port->port_conf->path_id;
238 	int tx_qno = t7xx_port_get_queue_no(port);
239 	struct cldma_ctrl *md_ctrl;
240 
241 	md_ctrl = port->t7xx_dev->md->md_ctrl[path_id];
242 	return md_ctrl->tx_ring[tx_qno].pkt_size;
243 }
244 
245 int t7xx_port_send_raw_skb(struct t7xx_port *port, struct sk_buff *skb)
246 {
247 	enum cldma_id path_id = port->port_conf->path_id;
248 	struct cldma_ctrl *md_ctrl;
249 	int ret, tx_qno;
250 
251 	md_ctrl = port->t7xx_dev->md->md_ctrl[path_id];
252 	tx_qno = t7xx_port_get_queue_no(port);
253 	ret = t7xx_cldma_send_skb(md_ctrl, tx_qno, skb);
254 	if (ret)
255 		dev_err(port->dev, "Failed to send skb: %d\n", ret);
256 
257 	return ret;
258 }
259 
260 static int t7xx_port_send_ccci_skb(struct t7xx_port *port, struct sk_buff *skb,
261 				   unsigned int pkt_header, unsigned int ex_msg)
262 {
263 	const struct t7xx_port_conf *port_conf = port->port_conf;
264 	struct ccci_header *ccci_h;
265 	u32 status;
266 	int ret;
267 
268 	ccci_h = skb_push(skb, sizeof(*ccci_h));
269 	status = FIELD_PREP(CCCI_H_CHN_FLD, port_conf->tx_ch) |
270 		 FIELD_PREP(CCCI_H_SEQ_FLD, port->seq_nums[MTK_TX]) | CCCI_H_AST_BIT;
271 	ccci_h->status = cpu_to_le32(status);
272 	ccci_h->packet_header = cpu_to_le32(pkt_header);
273 	ccci_h->packet_len = cpu_to_le32(skb->len);
274 	ccci_h->ex_msg = cpu_to_le32(ex_msg);
275 
276 	ret = t7xx_port_send_raw_skb(port, skb);
277 	if (ret)
278 		return ret;
279 
280 	port->seq_nums[MTK_TX]++;
281 	return 0;
282 }
283 
284 int t7xx_port_send_ctl_skb(struct t7xx_port *port, struct sk_buff *skb, unsigned int msg,
285 			   unsigned int ex_msg)
286 {
287 	struct ctrl_msg_header *ctrl_msg_h;
288 	unsigned int msg_len = skb->len;
289 	u32 pkt_header = 0;
290 
291 	ctrl_msg_h = skb_push(skb, sizeof(*ctrl_msg_h));
292 	ctrl_msg_h->ctrl_msg_id = cpu_to_le32(msg);
293 	ctrl_msg_h->ex_msg = cpu_to_le32(ex_msg);
294 	ctrl_msg_h->data_length = cpu_to_le32(msg_len);
295 
296 	if (!msg_len)
297 		pkt_header = CCCI_HEADER_NO_DATA;
298 
299 	return t7xx_port_send_ccci_skb(port, skb, pkt_header, ex_msg);
300 }
301 
302 int t7xx_port_send_skb(struct t7xx_port *port, struct sk_buff *skb, unsigned int pkt_header,
303 		       unsigned int ex_msg)
304 {
305 	struct t7xx_fsm_ctl *ctl = port->t7xx_dev->md->fsm_ctl;
306 	unsigned int fsm_state;
307 
308 	fsm_state = t7xx_fsm_get_ctl_state(ctl);
309 	if (fsm_state != FSM_STATE_PRE_START) {
310 		const struct t7xx_port_conf *port_conf = port->port_conf;
311 		enum md_state md_state = t7xx_fsm_get_md_state(ctl);
312 
313 		switch (md_state) {
314 		case MD_STATE_EXCEPTION:
315 			if (port_conf->tx_ch != PORT_CH_MD_LOG_TX)
316 				return -EBUSY;
317 			break;
318 
319 		case MD_STATE_WAITING_FOR_HS1:
320 		case MD_STATE_WAITING_FOR_HS2:
321 		case MD_STATE_STOPPED:
322 		case MD_STATE_WAITING_TO_STOP:
323 		case MD_STATE_INVALID:
324 			return -ENODEV;
325 
326 		default:
327 			break;
328 		}
329 	}
330 
331 	return t7xx_port_send_ccci_skb(port, skb, pkt_header, ex_msg);
332 }
333 
334 static void t7xx_proxy_setup_ch_mapping(struct port_proxy *port_prox)
335 {
336 	struct t7xx_port *port;
337 
338 	int i, j;
339 
340 	for (i = 0; i < ARRAY_SIZE(port_prox->rx_ch_ports); i++)
341 		INIT_LIST_HEAD(&port_prox->rx_ch_ports[i]);
342 
343 	for (j = 0; j < ARRAY_SIZE(port_prox->queue_ports); j++) {
344 		for (i = 0; i < ARRAY_SIZE(port_prox->queue_ports[j]); i++)
345 			INIT_LIST_HEAD(&port_prox->queue_ports[j][i]);
346 	}
347 
348 	for_each_proxy_port(i, port, port_prox) {
349 		const struct t7xx_port_conf *port_conf = port->port_conf;
350 		enum cldma_id path_id = port_conf->path_id;
351 		u8 ch_id;
352 
353 		ch_id = FIELD_GET(PORT_CH_ID_MASK, port_conf->rx_ch);
354 		list_add_tail(&port->entry, &port_prox->rx_ch_ports[ch_id]);
355 		list_add_tail(&port->queue_entry,
356 			      &port_prox->queue_ports[path_id][port_conf->rxq_index]);
357 	}
358 }
359 
360 /**
361  * t7xx_port_proxy_recv_skb_from_dedicated_queue() - Dispatch early port received skb.
362  * @queue: CLDMA queue.
363  * @skb: Socket buffer.
364  *
365  * Return:
366  ** 0		- Packet consumed.
367  ** -ERROR	- Failed to process skb.
368  */
369 int t7xx_port_proxy_recv_skb_from_dedicated_queue(struct cldma_queue *queue, struct sk_buff *skb)
370 {
371 	struct t7xx_pci_dev *t7xx_dev = queue->md_ctrl->t7xx_dev;
372 	struct port_proxy *port_prox = t7xx_dev->md->port_prox;
373 	const struct t7xx_port_conf *port_conf;
374 	struct t7xx_port *port;
375 	int ret;
376 
377 	port = &port_prox->ports[0];
378 	if (WARN_ON_ONCE(port->port_conf->rxq_index != queue->index)) {
379 		dev_kfree_skb_any(skb);
380 		return -EINVAL;
381 	}
382 
383 	port_conf = port->port_conf;
384 	ret = port_conf->ops->recv_skb(port, skb);
385 	if (ret < 0 && ret != -ENOBUFS) {
386 		dev_err(port->dev, "drop on RX ch %d, %d\n", port_conf->rx_ch, ret);
387 		dev_kfree_skb_any(skb);
388 	}
389 
390 	return ret;
391 }
392 
393 static struct t7xx_port *t7xx_port_proxy_find_port(struct t7xx_pci_dev *t7xx_dev,
394 						   struct cldma_queue *queue, u16 channel)
395 {
396 	struct port_proxy *port_prox = t7xx_dev->md->port_prox;
397 	struct list_head *port_list;
398 	struct t7xx_port *port;
399 	u8 ch_id;
400 
401 	ch_id = FIELD_GET(PORT_CH_ID_MASK, channel);
402 	port_list = &port_prox->rx_ch_ports[ch_id];
403 	list_for_each_entry(port, port_list, entry) {
404 		const struct t7xx_port_conf *port_conf = port->port_conf;
405 
406 		if (queue->md_ctrl->hif_id == port_conf->path_id &&
407 		    channel == port_conf->rx_ch)
408 			return port;
409 	}
410 
411 	return NULL;
412 }
413 
414 /**
415  * t7xx_port_proxy_recv_skb() - Dispatch received skb.
416  * @queue: CLDMA queue.
417  * @skb: Socket buffer.
418  *
419  * Return:
420  ** 0		- Packet consumed.
421  ** -ERROR	- Failed to process skb.
422  */
423 int t7xx_port_proxy_recv_skb(struct cldma_queue *queue, struct sk_buff *skb)
424 {
425 	struct ccci_header *ccci_h = (struct ccci_header *)skb->data;
426 	struct t7xx_pci_dev *t7xx_dev = queue->md_ctrl->t7xx_dev;
427 	struct t7xx_fsm_ctl *ctl = t7xx_dev->md->fsm_ctl;
428 	struct device *dev = queue->md_ctrl->dev;
429 	const struct t7xx_port_conf *port_conf;
430 	struct t7xx_port *port;
431 	u16 seq_num, channel;
432 	int ret;
433 
434 	channel = FIELD_GET(CCCI_H_CHN_FLD, le32_to_cpu(ccci_h->status));
435 	if (t7xx_fsm_get_md_state(ctl) == MD_STATE_INVALID) {
436 		dev_err_ratelimited(dev, "Packet drop on channel 0x%x, modem not ready\n", channel);
437 		goto drop_skb;
438 	}
439 
440 	port = t7xx_port_proxy_find_port(t7xx_dev, queue, channel);
441 	if (!port) {
442 		dev_err_ratelimited(dev, "Packet drop on channel 0x%x, port not found\n", channel);
443 		goto drop_skb;
444 	}
445 
446 	seq_num = t7xx_port_next_rx_seq_num(port, ccci_h);
447 	port_conf = port->port_conf;
448 	skb_pull(skb, sizeof(*ccci_h));
449 
450 	ret = port_conf->ops->recv_skb(port, skb);
451 	/* Error indicates to try again later */
452 	if (ret) {
453 		skb_push(skb, sizeof(*ccci_h));
454 		return ret;
455 	}
456 
457 	port->seq_nums[MTK_RX] = seq_num;
458 	return 0;
459 
460 drop_skb:
461 	dev_kfree_skb_any(skb);
462 	return 0;
463 }
464 
465 /**
466  * t7xx_port_proxy_md_status_notify() - Notify all ports of state.
467  *@port_prox: The port_proxy pointer.
468  *@state: State.
469  *
470  * Called by t7xx_fsm. Used to dispatch modem status for all ports,
471  * which want to know MD state transition.
472  */
473 void t7xx_port_proxy_md_status_notify(struct port_proxy *port_prox, unsigned int state)
474 {
475 	struct t7xx_port *port;
476 	int i;
477 
478 	for_each_proxy_port(i, port, port_prox) {
479 		const struct t7xx_port_conf *port_conf = port->port_conf;
480 
481 		if (port_conf->ops->md_state_notify)
482 			port_conf->ops->md_state_notify(port, state);
483 	}
484 }
485 
486 static void t7xx_proxy_init_all_ports(struct t7xx_modem *md)
487 {
488 	struct port_proxy *port_prox = md->port_prox;
489 	struct t7xx_port *port;
490 	int i;
491 
492 	for_each_proxy_port(i, port, port_prox) {
493 		const struct t7xx_port_conf *port_conf = port->port_conf;
494 
495 		t7xx_port_struct_init(port);
496 
497 		if (port_conf->tx_ch == PORT_CH_CONTROL_TX)
498 			md->core_md.ctl_port = port;
499 
500 		if (port_conf->tx_ch == PORT_CH_AP_CONTROL_TX)
501 			md->core_ap.ctl_port = port;
502 
503 		port->t7xx_dev = md->t7xx_dev;
504 		port->dev = &md->t7xx_dev->pdev->dev;
505 		spin_lock_init(&port->port_update_lock);
506 		port->chan_enable = false;
507 
508 		if (port_conf->ops && port_conf->ops->init)
509 			port_conf->ops->init(port);
510 	}
511 
512 	t7xx_proxy_setup_ch_mapping(port_prox);
513 }
514 
515 void t7xx_port_proxy_set_cfg(struct t7xx_modem *md, enum port_cfg_id cfg_id)
516 {
517 	struct port_proxy *port_prox = md->port_prox;
518 	const struct t7xx_port_conf *port_conf;
519 	u32 port_count;
520 	int i;
521 
522 	t7xx_port_proxy_uninit(port_prox);
523 
524 	if (cfg_id == PORT_CFG_ID_EARLY) {
525 		port_conf = t7xx_early_port_conf;
526 		port_count = ARRAY_SIZE(t7xx_early_port_conf);
527 	} else {
528 		port_conf = t7xx_port_conf;
529 		port_count = ARRAY_SIZE(t7xx_port_conf);
530 	}
531 
532 	for (i = 0; i < port_count; i++)
533 		port_prox->ports[i].port_conf = &port_conf[i];
534 
535 	port_prox->cfg_id = cfg_id;
536 	port_prox->port_count = port_count;
537 
538 	t7xx_proxy_init_all_ports(md);
539 }
540 
541 static int t7xx_proxy_alloc(struct t7xx_modem *md)
542 {
543 	struct device *dev = &md->t7xx_dev->pdev->dev;
544 	struct port_proxy *port_prox;
545 
546 	port_prox = devm_kzalloc(dev,
547 				 struct_size(port_prox,
548 					     ports,
549 					     T7XX_MAX_POSSIBLE_PORTS_NUM),
550 				 GFP_KERNEL);
551 	if (!port_prox)
552 		return -ENOMEM;
553 
554 	md->port_prox = port_prox;
555 	port_prox->dev = dev;
556 	t7xx_port_proxy_set_cfg(md, PORT_CFG_ID_EARLY);
557 
558 	return 0;
559 }
560 
561 /**
562  * t7xx_port_proxy_init() - Initialize ports.
563  * @md: Modem.
564  *
565  * Create all port instances.
566  *
567  * Return:
568  * * 0		- Success.
569  * * -ERROR	- Error code from failure sub-initializations.
570  */
571 int t7xx_port_proxy_init(struct t7xx_modem *md)
572 {
573 	int ret;
574 
575 	ret = t7xx_proxy_alloc(md);
576 	if (ret)
577 		return ret;
578 
579 	return 0;
580 }
581 
582 void t7xx_port_proxy_uninit(struct port_proxy *port_prox)
583 {
584 	struct t7xx_port *port;
585 	int i;
586 
587 	for_each_proxy_port(i, port, port_prox) {
588 		const struct t7xx_port_conf *port_conf = port->port_conf;
589 
590 		if (port_conf->ops && port_conf->ops->uninit)
591 			port_conf->ops->uninit(port);
592 	}
593 }
594 
595 int t7xx_port_proxy_chl_enable_disable(struct port_proxy *port_prox, unsigned int ch_id,
596 				       bool en_flag)
597 {
598 	struct t7xx_port *port = t7xx_proxy_get_port_by_ch(port_prox, ch_id);
599 	const struct t7xx_port_conf *port_conf;
600 
601 	if (!port)
602 		return -EINVAL;
603 
604 	port_conf = port->port_conf;
605 
606 	if (en_flag) {
607 		if (port_conf->ops->enable_chl)
608 			port_conf->ops->enable_chl(port);
609 	} else {
610 		if (port_conf->ops->disable_chl)
611 			port_conf->ops->disable_chl(port);
612 	}
613 
614 	return 0;
615 }
616