xref: /openbmc/linux/drivers/usb/serial/upd78f0730.c (revision f3d7c2cd)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Renesas Electronics uPD78F0730 USB to serial converter driver
4  *
5  * Copyright (C) 2014,2016 Maksim Salau <maksim.salau@gmail.com>
6  *
7  * Protocol of the adaptor is described in the application note U19660EJ1V0AN00
8  * μPD78F0730 8-bit Single-Chip Microcontroller
9  * USB-to-Serial Conversion Software
10  * <https://www.renesas.com/en-eu/doc/DocumentServer/026/U19660EJ1V0AN00.pdf>
11  *
12  * The adaptor functionality is limited to the following:
13  * - data bits: 7 or 8
14  * - stop bits: 1 or 2
15  * - parity: even, odd or none
16  * - flow control: none
17  * - baud rates: 0, 2400, 4800, 9600, 19200, 38400, 57600, 115200, 153600
18  * - signals: DTR, RTS and BREAK
19  */
20 
21 #include <linux/module.h>
22 #include <linux/slab.h>
23 #include <linux/tty.h>
24 #include <linux/usb.h>
25 #include <linux/usb/serial.h>
26 
27 #define DRIVER_DESC "Renesas uPD78F0730 USB to serial converter driver"
28 
29 #define DRIVER_AUTHOR "Maksim Salau <maksim.salau@gmail.com>"
30 
31 static const struct usb_device_id id_table[] = {
32 	{ USB_DEVICE(0x0409, 0x0063) }, /* V850ESJX3-STICK */
33 	{ USB_DEVICE(0x045B, 0x0212) }, /* YRPBRL78G13, YRPBRL78G14 */
34 	{ USB_DEVICE(0x064B, 0x7825) }, /* Analog Devices EVAL-ADXL362Z-DB */
35 	{}
36 };
37 
38 MODULE_DEVICE_TABLE(usb, id_table);
39 
40 /*
41  * Each adaptor is associated with a private structure, that holds the current
42  * state of control signals (DTR, RTS and BREAK).
43  */
44 struct upd78f0730_port_private {
45 	struct mutex	lock;		/* mutex to protect line_signals */
46 	u8		line_signals;
47 };
48 
49 /* Op-codes of control commands */
50 #define UPD78F0730_CMD_LINE_CONTROL	0x00
51 #define UPD78F0730_CMD_SET_DTR_RTS	0x01
52 #define UPD78F0730_CMD_SET_XON_XOFF_CHR	0x02
53 #define UPD78F0730_CMD_OPEN_CLOSE	0x03
54 #define UPD78F0730_CMD_SET_ERR_CHR	0x04
55 
56 /* Data sizes in UPD78F0730_CMD_LINE_CONTROL command */
57 #define UPD78F0730_DATA_SIZE_7_BITS	0x00
58 #define UPD78F0730_DATA_SIZE_8_BITS	0x01
59 #define UPD78F0730_DATA_SIZE_MASK	0x01
60 
61 /* Stop-bit modes in UPD78F0730_CMD_LINE_CONTROL command */
62 #define UPD78F0730_STOP_BIT_1_BIT	0x00
63 #define UPD78F0730_STOP_BIT_2_BIT	0x02
64 #define UPD78F0730_STOP_BIT_MASK	0x02
65 
66 /* Parity modes in UPD78F0730_CMD_LINE_CONTROL command */
67 #define UPD78F0730_PARITY_NONE	0x00
68 #define UPD78F0730_PARITY_EVEN	0x04
69 #define UPD78F0730_PARITY_ODD	0x08
70 #define UPD78F0730_PARITY_MASK	0x0C
71 
72 /* Flow control modes in UPD78F0730_CMD_LINE_CONTROL command */
73 #define UPD78F0730_FLOW_CONTROL_NONE	0x00
74 #define UPD78F0730_FLOW_CONTROL_HW	0x10
75 #define UPD78F0730_FLOW_CONTROL_SW	0x20
76 #define UPD78F0730_FLOW_CONTROL_MASK	0x30
77 
78 /* Control signal bits in UPD78F0730_CMD_SET_DTR_RTS command */
79 #define UPD78F0730_RTS		0x01
80 #define UPD78F0730_DTR		0x02
81 #define UPD78F0730_BREAK	0x04
82 
83 /* Port modes in UPD78F0730_CMD_OPEN_CLOSE command */
84 #define UPD78F0730_PORT_CLOSE	0x00
85 #define UPD78F0730_PORT_OPEN	0x01
86 
87 /* Error character substitution modes in UPD78F0730_CMD_SET_ERR_CHR command */
88 #define UPD78F0730_ERR_CHR_DISABLED	0x00
89 #define UPD78F0730_ERR_CHR_ENABLED	0x01
90 
91 /*
92  * Declaration of command structures
93  */
94 
95 /* UPD78F0730_CMD_LINE_CONTROL command */
96 struct upd78f0730_line_control {
97 	u8	opcode;
98 	__le32	baud_rate;
99 	u8	params;
100 } __packed;
101 
102 /* UPD78F0730_CMD_SET_DTR_RTS command */
103 struct upd78f0730_set_dtr_rts {
104 	u8 opcode;
105 	u8 params;
106 };
107 
108 /* UPD78F0730_CMD_SET_XON_OFF_CHR command */
109 struct upd78f0730_set_xon_xoff_chr {
110 	u8 opcode;
111 	u8 xon;
112 	u8 xoff;
113 };
114 
115 /* UPD78F0730_CMD_OPEN_CLOSE command */
116 struct upd78f0730_open_close {
117 	u8 opcode;
118 	u8 state;
119 };
120 
121 /* UPD78F0730_CMD_SET_ERR_CHR command */
122 struct upd78f0730_set_err_chr {
123 	u8 opcode;
124 	u8 state;
125 	u8 err_char;
126 };
127 
128 static int upd78f0730_send_ctl(struct usb_serial_port *port,
129 			const void *data, int size)
130 {
131 	struct usb_device *usbdev = port->serial->dev;
132 	void *buf;
133 	int res;
134 
135 	if (size <= 0 || !data)
136 		return -EINVAL;
137 
138 	buf = kmemdup(data, size, GFP_KERNEL);
139 	if (!buf)
140 		return -ENOMEM;
141 
142 	res = usb_control_msg(usbdev, usb_sndctrlpipe(usbdev, 0), 0x00,
143 			USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,
144 			0x0000, 0x0000, buf, size, USB_CTRL_SET_TIMEOUT);
145 
146 	kfree(buf);
147 
148 	if (res < 0) {
149 		struct device *dev = &port->dev;
150 
151 		dev_err(dev, "failed to send control request %02x: %d\n",
152 			*(u8 *)data, res);
153 
154 		return res;
155 	}
156 
157 	return 0;
158 }
159 
160 static int upd78f0730_port_probe(struct usb_serial_port *port)
161 {
162 	struct upd78f0730_port_private *private;
163 
164 	private = kzalloc(sizeof(*private), GFP_KERNEL);
165 	if (!private)
166 		return -ENOMEM;
167 
168 	mutex_init(&private->lock);
169 	usb_set_serial_port_data(port, private);
170 
171 	return 0;
172 }
173 
174 static void upd78f0730_port_remove(struct usb_serial_port *port)
175 {
176 	struct upd78f0730_port_private *private;
177 
178 	private = usb_get_serial_port_data(port);
179 	mutex_destroy(&private->lock);
180 	kfree(private);
181 }
182 
183 static int upd78f0730_tiocmget(struct tty_struct *tty)
184 {
185 	struct upd78f0730_port_private *private;
186 	struct usb_serial_port *port = tty->driver_data;
187 	int signals;
188 	int res;
189 
190 	private = usb_get_serial_port_data(port);
191 
192 	mutex_lock(&private->lock);
193 	signals = private->line_signals;
194 	mutex_unlock(&private->lock);
195 
196 	res = ((signals & UPD78F0730_DTR) ? TIOCM_DTR : 0) |
197 		((signals & UPD78F0730_RTS) ? TIOCM_RTS : 0);
198 
199 	dev_dbg(&port->dev, "%s - res = %x\n", __func__, res);
200 
201 	return res;
202 }
203 
204 static int upd78f0730_tiocmset(struct tty_struct *tty,
205 			unsigned int set, unsigned int clear)
206 {
207 	struct usb_serial_port *port = tty->driver_data;
208 	struct upd78f0730_port_private *private;
209 	struct upd78f0730_set_dtr_rts request;
210 	struct device *dev = &port->dev;
211 	int res;
212 
213 	private = usb_get_serial_port_data(port);
214 
215 	mutex_lock(&private->lock);
216 	if (set & TIOCM_DTR) {
217 		private->line_signals |= UPD78F0730_DTR;
218 		dev_dbg(dev, "%s - set DTR\n", __func__);
219 	}
220 	if (set & TIOCM_RTS) {
221 		private->line_signals |= UPD78F0730_RTS;
222 		dev_dbg(dev, "%s - set RTS\n", __func__);
223 	}
224 	if (clear & TIOCM_DTR) {
225 		private->line_signals &= ~UPD78F0730_DTR;
226 		dev_dbg(dev, "%s - clear DTR\n", __func__);
227 	}
228 	if (clear & TIOCM_RTS) {
229 		private->line_signals &= ~UPD78F0730_RTS;
230 		dev_dbg(dev, "%s - clear RTS\n", __func__);
231 	}
232 	request.opcode = UPD78F0730_CMD_SET_DTR_RTS;
233 	request.params = private->line_signals;
234 
235 	res = upd78f0730_send_ctl(port, &request, sizeof(request));
236 	mutex_unlock(&private->lock);
237 
238 	return res;
239 }
240 
241 static void upd78f0730_break_ctl(struct tty_struct *tty, int break_state)
242 {
243 	struct upd78f0730_port_private *private;
244 	struct usb_serial_port *port = tty->driver_data;
245 	struct upd78f0730_set_dtr_rts request;
246 	struct device *dev = &port->dev;
247 
248 	private = usb_get_serial_port_data(port);
249 
250 	mutex_lock(&private->lock);
251 	if (break_state) {
252 		private->line_signals |= UPD78F0730_BREAK;
253 		dev_dbg(dev, "%s - set BREAK\n", __func__);
254 	} else {
255 		private->line_signals &= ~UPD78F0730_BREAK;
256 		dev_dbg(dev, "%s - clear BREAK\n", __func__);
257 	}
258 	request.opcode = UPD78F0730_CMD_SET_DTR_RTS;
259 	request.params = private->line_signals;
260 
261 	upd78f0730_send_ctl(port, &request, sizeof(request));
262 	mutex_unlock(&private->lock);
263 }
264 
265 static void upd78f0730_dtr_rts(struct usb_serial_port *port, int on)
266 {
267 	struct tty_struct *tty = port->port.tty;
268 	unsigned int set = 0;
269 	unsigned int clear = 0;
270 
271 	if (on)
272 		set = TIOCM_DTR | TIOCM_RTS;
273 	else
274 		clear = TIOCM_DTR | TIOCM_RTS;
275 
276 	upd78f0730_tiocmset(tty, set, clear);
277 }
278 
279 static speed_t upd78f0730_get_baud_rate(struct tty_struct *tty)
280 {
281 	const speed_t baud_rate = tty_get_baud_rate(tty);
282 	static const speed_t supported[] = {
283 		0, 2400, 4800, 9600, 19200, 38400, 57600, 115200, 153600
284 	};
285 	int i;
286 
287 	for (i = ARRAY_SIZE(supported) - 1; i >= 0; i--) {
288 		if (baud_rate == supported[i])
289 			return baud_rate;
290 	}
291 
292 	/* If the baud rate is not supported, switch to the default one */
293 	tty_encode_baud_rate(tty, 9600, 9600);
294 
295 	return tty_get_baud_rate(tty);
296 }
297 
298 static void upd78f0730_set_termios(struct tty_struct *tty,
299 				struct usb_serial_port *port,
300 				struct ktermios *old_termios)
301 {
302 	struct device *dev = &port->dev;
303 	struct upd78f0730_line_control request;
304 	speed_t baud_rate;
305 
306 	if (old_termios && !tty_termios_hw_change(&tty->termios, old_termios))
307 		return;
308 
309 	if (C_BAUD(tty) == B0)
310 		upd78f0730_dtr_rts(port, 0);
311 	else if (old_termios && (old_termios->c_cflag & CBAUD) == B0)
312 		upd78f0730_dtr_rts(port, 1);
313 
314 	baud_rate = upd78f0730_get_baud_rate(tty);
315 	request.opcode = UPD78F0730_CMD_LINE_CONTROL;
316 	request.baud_rate = cpu_to_le32(baud_rate);
317 	request.params = 0;
318 	dev_dbg(dev, "%s - baud rate = %d\n", __func__, baud_rate);
319 
320 	switch (C_CSIZE(tty)) {
321 	case CS7:
322 		request.params |= UPD78F0730_DATA_SIZE_7_BITS;
323 		dev_dbg(dev, "%s - 7 data bits\n", __func__);
324 		break;
325 	default:
326 		tty->termios.c_cflag &= ~CSIZE;
327 		tty->termios.c_cflag |= CS8;
328 		dev_warn(dev, "data size is not supported, using 8 bits\n");
329 		fallthrough;
330 	case CS8:
331 		request.params |= UPD78F0730_DATA_SIZE_8_BITS;
332 		dev_dbg(dev, "%s - 8 data bits\n", __func__);
333 		break;
334 	}
335 
336 	if (C_PARENB(tty)) {
337 		if (C_PARODD(tty)) {
338 			request.params |= UPD78F0730_PARITY_ODD;
339 			dev_dbg(dev, "%s - odd parity\n", __func__);
340 		} else {
341 			request.params |= UPD78F0730_PARITY_EVEN;
342 			dev_dbg(dev, "%s - even parity\n", __func__);
343 		}
344 
345 		if (C_CMSPAR(tty)) {
346 			tty->termios.c_cflag &= ~CMSPAR;
347 			dev_warn(dev, "MARK/SPACE parity is not supported\n");
348 		}
349 	} else {
350 		request.params |= UPD78F0730_PARITY_NONE;
351 		dev_dbg(dev, "%s - no parity\n", __func__);
352 	}
353 
354 	if (C_CSTOPB(tty)) {
355 		request.params |= UPD78F0730_STOP_BIT_2_BIT;
356 		dev_dbg(dev, "%s - 2 stop bits\n", __func__);
357 	} else {
358 		request.params |= UPD78F0730_STOP_BIT_1_BIT;
359 		dev_dbg(dev, "%s - 1 stop bit\n", __func__);
360 	}
361 
362 	if (C_CRTSCTS(tty)) {
363 		tty->termios.c_cflag &= ~CRTSCTS;
364 		dev_warn(dev, "RTSCTS flow control is not supported\n");
365 	}
366 	if (I_IXOFF(tty) || I_IXON(tty)) {
367 		tty->termios.c_iflag &= ~(IXOFF | IXON);
368 		dev_warn(dev, "XON/XOFF flow control is not supported\n");
369 	}
370 	request.params |= UPD78F0730_FLOW_CONTROL_NONE;
371 	dev_dbg(dev, "%s - no flow control\n", __func__);
372 
373 	upd78f0730_send_ctl(port, &request, sizeof(request));
374 }
375 
376 static int upd78f0730_open(struct tty_struct *tty, struct usb_serial_port *port)
377 {
378 	static const struct upd78f0730_open_close request = {
379 		.opcode = UPD78F0730_CMD_OPEN_CLOSE,
380 		.state = UPD78F0730_PORT_OPEN
381 	};
382 	int res;
383 
384 	res = upd78f0730_send_ctl(port, &request, sizeof(request));
385 	if (res)
386 		return res;
387 
388 	if (tty)
389 		upd78f0730_set_termios(tty, port, NULL);
390 
391 	return usb_serial_generic_open(tty, port);
392 }
393 
394 static void upd78f0730_close(struct usb_serial_port *port)
395 {
396 	static const struct upd78f0730_open_close request = {
397 		.opcode = UPD78F0730_CMD_OPEN_CLOSE,
398 		.state = UPD78F0730_PORT_CLOSE
399 	};
400 
401 	usb_serial_generic_close(port);
402 	upd78f0730_send_ctl(port, &request, sizeof(request));
403 }
404 
405 static struct usb_serial_driver upd78f0730_device = {
406 	.driver	 = {
407 		.owner	= THIS_MODULE,
408 		.name	= "upd78f0730",
409 	},
410 	.id_table	= id_table,
411 	.num_ports	= 1,
412 	.port_probe	= upd78f0730_port_probe,
413 	.port_remove	= upd78f0730_port_remove,
414 	.open		= upd78f0730_open,
415 	.close		= upd78f0730_close,
416 	.set_termios	= upd78f0730_set_termios,
417 	.tiocmget	= upd78f0730_tiocmget,
418 	.tiocmset	= upd78f0730_tiocmset,
419 	.dtr_rts	= upd78f0730_dtr_rts,
420 	.break_ctl	= upd78f0730_break_ctl,
421 };
422 
423 static struct usb_serial_driver * const serial_drivers[] = {
424 	&upd78f0730_device,
425 	NULL
426 };
427 
428 module_usb_serial_driver(serial_drivers, id_table);
429 
430 MODULE_DESCRIPTION(DRIVER_DESC);
431 MODULE_AUTHOR(DRIVER_AUTHOR);
432 MODULE_LICENSE("GPL v2");
433