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 static const struct t7xx_port_conf t7xx_port_conf[] = {
52 	{
53 		.tx_ch = PORT_CH_UART2_TX,
54 		.rx_ch = PORT_CH_UART2_RX,
55 		.txq_index = Q_IDX_AT_CMD,
56 		.rxq_index = Q_IDX_AT_CMD,
57 		.txq_exp_index = 0xff,
58 		.rxq_exp_index = 0xff,
59 		.path_id = CLDMA_ID_MD,
60 		.ops = &wwan_sub_port_ops,
61 		.name = "AT",
62 		.port_type = WWAN_PORT_AT,
63 	}, {
64 		.tx_ch = PORT_CH_MBIM_TX,
65 		.rx_ch = PORT_CH_MBIM_RX,
66 		.txq_index = Q_IDX_MBIM,
67 		.rxq_index = Q_IDX_MBIM,
68 		.path_id = CLDMA_ID_MD,
69 		.ops = &wwan_sub_port_ops,
70 		.name = "MBIM",
71 		.port_type = WWAN_PORT_MBIM,
72 	}, {
73 #ifdef CONFIG_WWAN_DEBUGFS
74 		.tx_ch = PORT_CH_MD_LOG_TX,
75 		.rx_ch = PORT_CH_MD_LOG_RX,
76 		.txq_index = 7,
77 		.rxq_index = 7,
78 		.txq_exp_index = 7,
79 		.rxq_exp_index = 7,
80 		.path_id = CLDMA_ID_MD,
81 		.ops = &t7xx_trace_port_ops,
82 		.name = "mdlog",
83 	}, {
84 #endif
85 		.tx_ch = PORT_CH_CONTROL_TX,
86 		.rx_ch = PORT_CH_CONTROL_RX,
87 		.txq_index = Q_IDX_CTRL,
88 		.rxq_index = Q_IDX_CTRL,
89 		.path_id = CLDMA_ID_MD,
90 		.ops = &ctl_port_ops,
91 		.name = "t7xx_ctrl",
92 	}, {
93 		.tx_ch = PORT_CH_AP_CONTROL_TX,
94 		.rx_ch = PORT_CH_AP_CONTROL_RX,
95 		.txq_index = Q_IDX_CTRL,
96 		.rxq_index = Q_IDX_CTRL,
97 		.path_id = CLDMA_ID_AP,
98 		.ops = &ctl_port_ops,
99 		.name = "t7xx_ap_ctrl",
100 	},
101 };
102 
103 static struct t7xx_port *t7xx_proxy_get_port_by_ch(struct port_proxy *port_prox, enum port_ch ch)
104 {
105 	const struct t7xx_port_conf *port_conf;
106 	struct t7xx_port *port;
107 	int i;
108 
109 	for_each_proxy_port(i, port, port_prox) {
110 		port_conf = port->port_conf;
111 		if (port_conf->rx_ch == ch || port_conf->tx_ch == ch)
112 			return port;
113 	}
114 
115 	return NULL;
116 }
117 
118 static u16 t7xx_port_next_rx_seq_num(struct t7xx_port *port, struct ccci_header *ccci_h)
119 {
120 	u32 status = le32_to_cpu(ccci_h->status);
121 	u16 seq_num, next_seq_num;
122 	bool assert_bit;
123 
124 	seq_num = FIELD_GET(CCCI_H_SEQ_FLD, status);
125 	next_seq_num = (seq_num + 1) & FIELD_MAX(CCCI_H_SEQ_FLD);
126 	assert_bit = status & CCCI_H_AST_BIT;
127 	if (!assert_bit || port->seq_nums[MTK_RX] == INVALID_SEQ_NUM)
128 		return next_seq_num;
129 
130 	if (seq_num != port->seq_nums[MTK_RX])
131 		dev_warn_ratelimited(port->dev,
132 				     "seq num out-of-order %u != %u (header %X, len %X)\n",
133 				     seq_num, port->seq_nums[MTK_RX],
134 				     le32_to_cpu(ccci_h->packet_header),
135 				     le32_to_cpu(ccci_h->packet_len));
136 
137 	return next_seq_num;
138 }
139 
140 void t7xx_port_proxy_reset(struct port_proxy *port_prox)
141 {
142 	struct t7xx_port *port;
143 	int i;
144 
145 	for_each_proxy_port(i, port, port_prox) {
146 		port->seq_nums[MTK_RX] = INVALID_SEQ_NUM;
147 		port->seq_nums[MTK_TX] = 0;
148 	}
149 }
150 
151 static int t7xx_port_get_queue_no(struct t7xx_port *port)
152 {
153 	const struct t7xx_port_conf *port_conf = port->port_conf;
154 	struct t7xx_fsm_ctl *ctl = port->t7xx_dev->md->fsm_ctl;
155 
156 	return t7xx_fsm_get_md_state(ctl) == MD_STATE_EXCEPTION ?
157 		port_conf->txq_exp_index : port_conf->txq_index;
158 }
159 
160 static void t7xx_port_struct_init(struct t7xx_port *port)
161 {
162 	INIT_LIST_HEAD(&port->entry);
163 	INIT_LIST_HEAD(&port->queue_entry);
164 	skb_queue_head_init(&port->rx_skb_list);
165 	init_waitqueue_head(&port->rx_wq);
166 	port->seq_nums[MTK_RX] = INVALID_SEQ_NUM;
167 	port->seq_nums[MTK_TX] = 0;
168 	atomic_set(&port->usage_cnt, 0);
169 }
170 
171 struct sk_buff *t7xx_port_alloc_skb(int payload)
172 {
173 	struct sk_buff *skb = __dev_alloc_skb(payload + sizeof(struct ccci_header), GFP_KERNEL);
174 
175 	if (skb)
176 		skb_reserve(skb, sizeof(struct ccci_header));
177 
178 	return skb;
179 }
180 
181 struct sk_buff *t7xx_ctrl_alloc_skb(int payload)
182 {
183 	struct sk_buff *skb = t7xx_port_alloc_skb(payload + sizeof(struct ctrl_msg_header));
184 
185 	if (skb)
186 		skb_reserve(skb, sizeof(struct ctrl_msg_header));
187 
188 	return skb;
189 }
190 
191 /**
192  * t7xx_port_enqueue_skb() - Enqueue the received skb into the port's rx_skb_list.
193  * @port: port context.
194  * @skb: received skb.
195  *
196  * Return:
197  * * 0		- Success.
198  * * -ENOBUFS	- Not enough buffer space. Caller will try again later, skb is not consumed.
199  */
200 int t7xx_port_enqueue_skb(struct t7xx_port *port, struct sk_buff *skb)
201 {
202 	unsigned long flags;
203 
204 	spin_lock_irqsave(&port->rx_wq.lock, flags);
205 	if (port->rx_skb_list.qlen >= port->rx_length_th) {
206 		spin_unlock_irqrestore(&port->rx_wq.lock, flags);
207 
208 		return -ENOBUFS;
209 	}
210 	__skb_queue_tail(&port->rx_skb_list, skb);
211 	spin_unlock_irqrestore(&port->rx_wq.lock, flags);
212 
213 	wake_up_all(&port->rx_wq);
214 	return 0;
215 }
216 
217 static int t7xx_port_send_raw_skb(struct t7xx_port *port, struct sk_buff *skb)
218 {
219 	enum cldma_id path_id = port->port_conf->path_id;
220 	struct cldma_ctrl *md_ctrl;
221 	int ret, tx_qno;
222 
223 	md_ctrl = port->t7xx_dev->md->md_ctrl[path_id];
224 	tx_qno = t7xx_port_get_queue_no(port);
225 	ret = t7xx_cldma_send_skb(md_ctrl, tx_qno, skb);
226 	if (ret)
227 		dev_err(port->dev, "Failed to send skb: %d\n", ret);
228 
229 	return ret;
230 }
231 
232 static int t7xx_port_send_ccci_skb(struct t7xx_port *port, struct sk_buff *skb,
233 				   unsigned int pkt_header, unsigned int ex_msg)
234 {
235 	const struct t7xx_port_conf *port_conf = port->port_conf;
236 	struct ccci_header *ccci_h;
237 	u32 status;
238 	int ret;
239 
240 	ccci_h = skb_push(skb, sizeof(*ccci_h));
241 	status = FIELD_PREP(CCCI_H_CHN_FLD, port_conf->tx_ch) |
242 		 FIELD_PREP(CCCI_H_SEQ_FLD, port->seq_nums[MTK_TX]) | CCCI_H_AST_BIT;
243 	ccci_h->status = cpu_to_le32(status);
244 	ccci_h->packet_header = cpu_to_le32(pkt_header);
245 	ccci_h->packet_len = cpu_to_le32(skb->len);
246 	ccci_h->ex_msg = cpu_to_le32(ex_msg);
247 
248 	ret = t7xx_port_send_raw_skb(port, skb);
249 	if (ret)
250 		return ret;
251 
252 	port->seq_nums[MTK_TX]++;
253 	return 0;
254 }
255 
256 int t7xx_port_send_ctl_skb(struct t7xx_port *port, struct sk_buff *skb, unsigned int msg,
257 			   unsigned int ex_msg)
258 {
259 	struct ctrl_msg_header *ctrl_msg_h;
260 	unsigned int msg_len = skb->len;
261 	u32 pkt_header = 0;
262 
263 	ctrl_msg_h = skb_push(skb, sizeof(*ctrl_msg_h));
264 	ctrl_msg_h->ctrl_msg_id = cpu_to_le32(msg);
265 	ctrl_msg_h->ex_msg = cpu_to_le32(ex_msg);
266 	ctrl_msg_h->data_length = cpu_to_le32(msg_len);
267 
268 	if (!msg_len)
269 		pkt_header = CCCI_HEADER_NO_DATA;
270 
271 	return t7xx_port_send_ccci_skb(port, skb, pkt_header, ex_msg);
272 }
273 
274 int t7xx_port_send_skb(struct t7xx_port *port, struct sk_buff *skb, unsigned int pkt_header,
275 		       unsigned int ex_msg)
276 {
277 	struct t7xx_fsm_ctl *ctl = port->t7xx_dev->md->fsm_ctl;
278 	unsigned int fsm_state;
279 
280 	fsm_state = t7xx_fsm_get_ctl_state(ctl);
281 	if (fsm_state != FSM_STATE_PRE_START) {
282 		const struct t7xx_port_conf *port_conf = port->port_conf;
283 		enum md_state md_state = t7xx_fsm_get_md_state(ctl);
284 
285 		switch (md_state) {
286 		case MD_STATE_EXCEPTION:
287 			if (port_conf->tx_ch != PORT_CH_MD_LOG_TX)
288 				return -EBUSY;
289 			break;
290 
291 		case MD_STATE_WAITING_FOR_HS1:
292 		case MD_STATE_WAITING_FOR_HS2:
293 		case MD_STATE_STOPPED:
294 		case MD_STATE_WAITING_TO_STOP:
295 		case MD_STATE_INVALID:
296 			return -ENODEV;
297 
298 		default:
299 			break;
300 		}
301 	}
302 
303 	return t7xx_port_send_ccci_skb(port, skb, pkt_header, ex_msg);
304 }
305 
306 static void t7xx_proxy_setup_ch_mapping(struct port_proxy *port_prox)
307 {
308 	struct t7xx_port *port;
309 
310 	int i, j;
311 
312 	for (i = 0; i < ARRAY_SIZE(port_prox->rx_ch_ports); i++)
313 		INIT_LIST_HEAD(&port_prox->rx_ch_ports[i]);
314 
315 	for (j = 0; j < ARRAY_SIZE(port_prox->queue_ports); j++) {
316 		for (i = 0; i < ARRAY_SIZE(port_prox->queue_ports[j]); i++)
317 			INIT_LIST_HEAD(&port_prox->queue_ports[j][i]);
318 	}
319 
320 	for_each_proxy_port(i, port, port_prox) {
321 		const struct t7xx_port_conf *port_conf = port->port_conf;
322 		enum cldma_id path_id = port_conf->path_id;
323 		u8 ch_id;
324 
325 		ch_id = FIELD_GET(PORT_CH_ID_MASK, port_conf->rx_ch);
326 		list_add_tail(&port->entry, &port_prox->rx_ch_ports[ch_id]);
327 		list_add_tail(&port->queue_entry,
328 			      &port_prox->queue_ports[path_id][port_conf->rxq_index]);
329 	}
330 }
331 
332 static struct t7xx_port *t7xx_port_proxy_find_port(struct t7xx_pci_dev *t7xx_dev,
333 						   struct cldma_queue *queue, u16 channel)
334 {
335 	struct port_proxy *port_prox = t7xx_dev->md->port_prox;
336 	struct list_head *port_list;
337 	struct t7xx_port *port;
338 	u8 ch_id;
339 
340 	ch_id = FIELD_GET(PORT_CH_ID_MASK, channel);
341 	port_list = &port_prox->rx_ch_ports[ch_id];
342 	list_for_each_entry(port, port_list, entry) {
343 		const struct t7xx_port_conf *port_conf = port->port_conf;
344 
345 		if (queue->md_ctrl->hif_id == port_conf->path_id &&
346 		    channel == port_conf->rx_ch)
347 			return port;
348 	}
349 
350 	return NULL;
351 }
352 
353 /**
354  * t7xx_port_proxy_recv_skb() - Dispatch received skb.
355  * @queue: CLDMA queue.
356  * @skb: Socket buffer.
357  *
358  * Return:
359  ** 0		- Packet consumed.
360  ** -ERROR	- Failed to process skb.
361  */
362 static int t7xx_port_proxy_recv_skb(struct cldma_queue *queue, struct sk_buff *skb)
363 {
364 	struct ccci_header *ccci_h = (struct ccci_header *)skb->data;
365 	struct t7xx_pci_dev *t7xx_dev = queue->md_ctrl->t7xx_dev;
366 	struct t7xx_fsm_ctl *ctl = t7xx_dev->md->fsm_ctl;
367 	struct device *dev = queue->md_ctrl->dev;
368 	const struct t7xx_port_conf *port_conf;
369 	struct t7xx_port *port;
370 	u16 seq_num, channel;
371 	int ret;
372 
373 	channel = FIELD_GET(CCCI_H_CHN_FLD, le32_to_cpu(ccci_h->status));
374 	if (t7xx_fsm_get_md_state(ctl) == MD_STATE_INVALID) {
375 		dev_err_ratelimited(dev, "Packet drop on channel 0x%x, modem not ready\n", channel);
376 		goto drop_skb;
377 	}
378 
379 	port = t7xx_port_proxy_find_port(t7xx_dev, queue, channel);
380 	if (!port) {
381 		dev_err_ratelimited(dev, "Packet drop on channel 0x%x, port not found\n", channel);
382 		goto drop_skb;
383 	}
384 
385 	seq_num = t7xx_port_next_rx_seq_num(port, ccci_h);
386 	port_conf = port->port_conf;
387 	skb_pull(skb, sizeof(*ccci_h));
388 
389 	ret = port_conf->ops->recv_skb(port, skb);
390 	/* Error indicates to try again later */
391 	if (ret) {
392 		skb_push(skb, sizeof(*ccci_h));
393 		return ret;
394 	}
395 
396 	port->seq_nums[MTK_RX] = seq_num;
397 	return 0;
398 
399 drop_skb:
400 	dev_kfree_skb_any(skb);
401 	return 0;
402 }
403 
404 /**
405  * t7xx_port_proxy_md_status_notify() - Notify all ports of state.
406  *@port_prox: The port_proxy pointer.
407  *@state: State.
408  *
409  * Called by t7xx_fsm. Used to dispatch modem status for all ports,
410  * which want to know MD state transition.
411  */
412 void t7xx_port_proxy_md_status_notify(struct port_proxy *port_prox, unsigned int state)
413 {
414 	struct t7xx_port *port;
415 	int i;
416 
417 	for_each_proxy_port(i, port, port_prox) {
418 		const struct t7xx_port_conf *port_conf = port->port_conf;
419 
420 		if (port_conf->ops->md_state_notify)
421 			port_conf->ops->md_state_notify(port, state);
422 	}
423 }
424 
425 static void t7xx_proxy_init_all_ports(struct t7xx_modem *md)
426 {
427 	struct port_proxy *port_prox = md->port_prox;
428 	struct t7xx_port *port;
429 	int i;
430 
431 	for_each_proxy_port(i, port, port_prox) {
432 		const struct t7xx_port_conf *port_conf = port->port_conf;
433 
434 		t7xx_port_struct_init(port);
435 
436 		if (port_conf->tx_ch == PORT_CH_CONTROL_TX)
437 			md->core_md.ctl_port = port;
438 
439 		if (port_conf->tx_ch == PORT_CH_AP_CONTROL_TX)
440 			md->core_ap.ctl_port = port;
441 
442 		port->t7xx_dev = md->t7xx_dev;
443 		port->dev = &md->t7xx_dev->pdev->dev;
444 		spin_lock_init(&port->port_update_lock);
445 		port->chan_enable = false;
446 
447 		if (port_conf->ops->init)
448 			port_conf->ops->init(port);
449 	}
450 
451 	t7xx_proxy_setup_ch_mapping(port_prox);
452 }
453 
454 static int t7xx_proxy_alloc(struct t7xx_modem *md)
455 {
456 	unsigned int port_count = ARRAY_SIZE(t7xx_port_conf);
457 	struct device *dev = &md->t7xx_dev->pdev->dev;
458 	struct port_proxy *port_prox;
459 	int i;
460 
461 	port_prox = devm_kzalloc(dev, sizeof(*port_prox) + sizeof(struct t7xx_port) * port_count,
462 				 GFP_KERNEL);
463 	if (!port_prox)
464 		return -ENOMEM;
465 
466 	md->port_prox = port_prox;
467 	port_prox->dev = dev;
468 
469 	for (i = 0; i < port_count; i++)
470 		port_prox->ports[i].port_conf = &t7xx_port_conf[i];
471 
472 	port_prox->port_count = port_count;
473 	t7xx_proxy_init_all_ports(md);
474 	return 0;
475 }
476 
477 /**
478  * t7xx_port_proxy_init() - Initialize ports.
479  * @md: Modem.
480  *
481  * Create all port instances.
482  *
483  * Return:
484  * * 0		- Success.
485  * * -ERROR	- Error code from failure sub-initializations.
486  */
487 int t7xx_port_proxy_init(struct t7xx_modem *md)
488 {
489 	int ret;
490 
491 	ret = t7xx_proxy_alloc(md);
492 	if (ret)
493 		return ret;
494 
495 	t7xx_cldma_set_recv_skb(md->md_ctrl[CLDMA_ID_AP], t7xx_port_proxy_recv_skb);
496 	t7xx_cldma_set_recv_skb(md->md_ctrl[CLDMA_ID_MD], t7xx_port_proxy_recv_skb);
497 	return 0;
498 }
499 
500 void t7xx_port_proxy_uninit(struct port_proxy *port_prox)
501 {
502 	struct t7xx_port *port;
503 	int i;
504 
505 	for_each_proxy_port(i, port, port_prox) {
506 		const struct t7xx_port_conf *port_conf = port->port_conf;
507 
508 		if (port_conf->ops->uninit)
509 			port_conf->ops->uninit(port);
510 	}
511 }
512 
513 int t7xx_port_proxy_chl_enable_disable(struct port_proxy *port_prox, unsigned int ch_id,
514 				       bool en_flag)
515 {
516 	struct t7xx_port *port = t7xx_proxy_get_port_by_ch(port_prox, ch_id);
517 	const struct t7xx_port_conf *port_conf;
518 
519 	if (!port)
520 		return -EINVAL;
521 
522 	port_conf = port->port_conf;
523 
524 	if (en_flag) {
525 		if (port_conf->ops->enable_chl)
526 			port_conf->ops->enable_chl(port);
527 	} else {
528 		if (port_conf->ops->disable_chl)
529 			port_conf->ops->disable_chl(port);
530 	}
531 
532 	return 0;
533 }
534