1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (c) 2012 GCT Semiconductor, Inc. All rights reserved. */
3 
4 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
5 
6 #include <linux/kernel.h>
7 #include <linux/errno.h>
8 #include <linux/tty.h>
9 #include <linux/tty_driver.h>
10 #include <linux/tty_flip.h>
11 #include <linux/module.h>
12 #include <linux/slab.h>
13 #include <linux/usb/cdc.h>
14 #include <linux/serial.h>
15 #include "gdm_tty.h"
16 
17 #define GDM_TTY_MAJOR 0
18 #define GDM_TTY_MINOR 32
19 
20 #define WRITE_SIZE 2048UL
21 
22 #define MUX_TX_MAX_SIZE 2048UL
23 
24 static inline bool gdm_tty_ready(struct gdm *gdm)
25 {
26 	return gdm && gdm->tty_dev && gdm->port.count;
27 }
28 
29 static struct tty_driver *gdm_driver[TTY_MAX_COUNT];
30 static struct gdm *gdm_table[TTY_MAX_COUNT][GDM_TTY_MINOR];
31 static DEFINE_MUTEX(gdm_table_lock);
32 
33 static const char *DRIVER_STRING[TTY_MAX_COUNT] = {"GCTATC", "GCTDM"};
34 static char *DEVICE_STRING[TTY_MAX_COUNT] = {"GCT-ATC", "GCT-DM"};
35 
36 static void gdm_port_destruct(struct tty_port *port)
37 {
38 	struct gdm *gdm = container_of(port, struct gdm, port);
39 
40 	mutex_lock(&gdm_table_lock);
41 	gdm_table[gdm->index][gdm->minor] = NULL;
42 	mutex_unlock(&gdm_table_lock);
43 
44 	kfree(gdm);
45 }
46 
47 static const struct tty_port_operations gdm_port_ops = {
48 	.destruct = gdm_port_destruct,
49 };
50 
51 static int gdm_tty_install(struct tty_driver *driver, struct tty_struct *tty)
52 {
53 	struct gdm *gdm = NULL;
54 	int ret;
55 
56 	ret = match_string(DRIVER_STRING, TTY_MAX_COUNT,
57 			   tty->driver->driver_name);
58 	if (ret < 0)
59 		return -ENODEV;
60 
61 	mutex_lock(&gdm_table_lock);
62 	gdm = gdm_table[ret][tty->index];
63 	if (!gdm) {
64 		mutex_unlock(&gdm_table_lock);
65 		return -ENODEV;
66 	}
67 
68 	tty_port_get(&gdm->port);
69 
70 	ret = tty_standard_install(driver, tty);
71 	if (ret) {
72 		tty_port_put(&gdm->port);
73 		mutex_unlock(&gdm_table_lock);
74 		return ret;
75 	}
76 
77 	tty->driver_data = gdm;
78 	mutex_unlock(&gdm_table_lock);
79 
80 	return 0;
81 }
82 
83 static int gdm_tty_open(struct tty_struct *tty, struct file *filp)
84 {
85 	struct gdm *gdm = tty->driver_data;
86 
87 	return tty_port_open(&gdm->port, tty, filp);
88 }
89 
90 static void gdm_tty_cleanup(struct tty_struct *tty)
91 {
92 	struct gdm *gdm = tty->driver_data;
93 
94 	tty_port_put(&gdm->port);
95 }
96 
97 static void gdm_tty_hangup(struct tty_struct *tty)
98 {
99 	struct gdm *gdm = tty->driver_data;
100 
101 	tty_port_hangup(&gdm->port);
102 }
103 
104 static void gdm_tty_close(struct tty_struct *tty, struct file *filp)
105 {
106 	struct gdm *gdm = tty->driver_data;
107 
108 	tty_port_close(&gdm->port, tty, filp);
109 }
110 
111 static int gdm_tty_recv_complete(void *data,
112 				 int len,
113 				 int index,
114 				 struct tty_dev *tty_dev,
115 				 int complete)
116 {
117 	struct gdm *gdm = tty_dev->gdm[index];
118 
119 	if (!gdm_tty_ready(gdm)) {
120 		if (complete == RECV_PACKET_PROCESS_COMPLETE)
121 			gdm->tty_dev->recv_func(gdm->tty_dev->priv_dev,
122 						gdm_tty_recv_complete);
123 		return TO_HOST_PORT_CLOSE;
124 	}
125 
126 	if (data && len) {
127 		if (tty_buffer_request_room(&gdm->port, len) == len) {
128 			tty_insert_flip_string(&gdm->port, data, len);
129 			tty_flip_buffer_push(&gdm->port);
130 		} else {
131 			return TO_HOST_BUFFER_REQUEST_FAIL;
132 		}
133 	}
134 
135 	if (complete == RECV_PACKET_PROCESS_COMPLETE)
136 		gdm->tty_dev->recv_func(gdm->tty_dev->priv_dev,
137 					gdm_tty_recv_complete);
138 
139 	return 0;
140 }
141 
142 static void gdm_tty_send_complete(void *arg)
143 {
144 	struct gdm *gdm = arg;
145 
146 	if (!gdm_tty_ready(gdm))
147 		return;
148 
149 	tty_port_tty_wakeup(&gdm->port);
150 }
151 
152 static ssize_t gdm_tty_write(struct tty_struct *tty, const u8 *buf, size_t len)
153 {
154 	struct gdm *gdm = tty->driver_data;
155 	size_t remain = len;
156 	size_t sent_len = 0;
157 
158 	if (!gdm_tty_ready(gdm))
159 		return -ENODEV;
160 
161 	while (remain) {
162 		size_t sending_len = min(MUX_TX_MAX_SIZE, remain);
163 		gdm->tty_dev->send_func(gdm->tty_dev->priv_dev,
164 					(void *)(buf + sent_len),
165 					sending_len,
166 					gdm->index,
167 					gdm_tty_send_complete,
168 					gdm);
169 		sent_len += sending_len;
170 		remain -= sending_len;
171 	}
172 
173 	return len;
174 }
175 
176 static unsigned int gdm_tty_write_room(struct tty_struct *tty)
177 {
178 	struct gdm *gdm = tty->driver_data;
179 
180 	if (!gdm_tty_ready(gdm))
181 		return 0;
182 
183 	return WRITE_SIZE;
184 }
185 
186 int register_lte_tty_device(struct tty_dev *tty_dev, struct device *device)
187 {
188 	struct gdm *gdm;
189 	int i;
190 	int j;
191 
192 	for (i = 0; i < TTY_MAX_COUNT; i++) {
193 		gdm = kmalloc(sizeof(*gdm), GFP_KERNEL);
194 		if (!gdm)
195 			return -ENOMEM;
196 
197 		mutex_lock(&gdm_table_lock);
198 		for (j = 0; j < GDM_TTY_MINOR; j++) {
199 			if (!gdm_table[i][j])
200 				break;
201 		}
202 
203 		if (j == GDM_TTY_MINOR) {
204 			kfree(gdm);
205 			mutex_unlock(&gdm_table_lock);
206 			return -EINVAL;
207 		}
208 
209 		gdm_table[i][j] = gdm;
210 		mutex_unlock(&gdm_table_lock);
211 
212 		tty_dev->gdm[i] = gdm;
213 		tty_port_init(&gdm->port);
214 
215 		gdm->port.ops = &gdm_port_ops;
216 		gdm->index = i;
217 		gdm->minor = j;
218 		gdm->tty_dev = tty_dev;
219 
220 		tty_port_register_device(&gdm->port, gdm_driver[i],
221 					 gdm->minor, device);
222 	}
223 
224 	for (i = 0; i < MAX_ISSUE_NUM; i++)
225 		gdm->tty_dev->recv_func(gdm->tty_dev->priv_dev,
226 					gdm_tty_recv_complete);
227 
228 	return 0;
229 }
230 
231 void unregister_lte_tty_device(struct tty_dev *tty_dev)
232 {
233 	struct gdm *gdm;
234 	struct tty_struct *tty;
235 	int i;
236 
237 	for (i = 0; i < TTY_MAX_COUNT; i++) {
238 		gdm = tty_dev->gdm[i];
239 		if (!gdm)
240 			continue;
241 
242 		mutex_lock(&gdm_table_lock);
243 		gdm_table[gdm->index][gdm->minor] = NULL;
244 		mutex_unlock(&gdm_table_lock);
245 
246 		tty = tty_port_tty_get(&gdm->port);
247 		if (tty) {
248 			tty_vhangup(tty);
249 			tty_kref_put(tty);
250 		}
251 
252 		tty_unregister_device(gdm_driver[i], gdm->minor);
253 		tty_port_put(&gdm->port);
254 	}
255 }
256 
257 static const struct tty_operations gdm_tty_ops = {
258 	.install =	gdm_tty_install,
259 	.open =		gdm_tty_open,
260 	.close =	gdm_tty_close,
261 	.cleanup =	gdm_tty_cleanup,
262 	.hangup =	gdm_tty_hangup,
263 	.write =	gdm_tty_write,
264 	.write_room =	gdm_tty_write_room,
265 };
266 
267 int register_lte_tty_driver(void)
268 {
269 	struct tty_driver *tty_driver;
270 	int i;
271 	int ret;
272 
273 	for (i = 0; i < TTY_MAX_COUNT; i++) {
274 		tty_driver = tty_alloc_driver(GDM_TTY_MINOR,
275 				TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV);
276 		if (IS_ERR(tty_driver))
277 			return PTR_ERR(tty_driver);
278 
279 		tty_driver->owner = THIS_MODULE;
280 		tty_driver->driver_name = DRIVER_STRING[i];
281 		tty_driver->name = DEVICE_STRING[i];
282 		tty_driver->major = GDM_TTY_MAJOR;
283 		tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
284 		tty_driver->subtype = SERIAL_TYPE_NORMAL;
285 		tty_driver->init_termios = tty_std_termios;
286 		tty_driver->init_termios.c_cflag = B9600 | CS8 | HUPCL | CLOCAL;
287 		tty_driver->init_termios.c_lflag = ISIG | ICANON | IEXTEN;
288 		tty_set_operations(tty_driver, &gdm_tty_ops);
289 
290 		ret = tty_register_driver(tty_driver);
291 		if (ret) {
292 			tty_driver_kref_put(tty_driver);
293 			return ret;
294 		}
295 
296 		gdm_driver[i] = tty_driver;
297 	}
298 
299 	return ret;
300 }
301 
302 void unregister_lte_tty_driver(void)
303 {
304 	struct tty_driver *tty_driver;
305 	int i;
306 
307 	for (i = 0; i < TTY_MAX_COUNT; i++) {
308 		tty_driver = gdm_driver[i];
309 		if (tty_driver) {
310 			tty_unregister_driver(tty_driver);
311 			tty_driver_kref_put(tty_driver);
312 		}
313 	}
314 }
315 
316