GNU Linux-libre 4.19.286-gnu1
[releases.git] / drivers / usb / serial / upd78f0730.c
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 != size) {
149                 struct device *dev = &port->dev;
150
151                 dev_err(dev, "failed to send control request %02x: %d\n",
152                         *(u8 *)data, res);
153                 /* The maximum expected length of a transfer is 6 bytes */
154                 if (res >= 0)
155                         res = -EIO;
156
157                 return res;
158         }
159
160         return 0;
161 }
162
163 static int upd78f0730_port_probe(struct usb_serial_port *port)
164 {
165         struct upd78f0730_port_private *private;
166
167         private = kzalloc(sizeof(*private), GFP_KERNEL);
168         if (!private)
169                 return -ENOMEM;
170
171         mutex_init(&private->lock);
172         usb_set_serial_port_data(port, private);
173
174         return 0;
175 }
176
177 static int upd78f0730_port_remove(struct usb_serial_port *port)
178 {
179         struct upd78f0730_port_private *private;
180
181         private = usb_get_serial_port_data(port);
182         mutex_destroy(&private->lock);
183         kfree(private);
184
185         return 0;
186 }
187
188 static int upd78f0730_tiocmget(struct tty_struct *tty)
189 {
190         struct device *dev = tty->dev;
191         struct upd78f0730_port_private *private;
192         struct usb_serial_port *port = tty->driver_data;
193         int signals;
194         int res;
195
196         private = usb_get_serial_port_data(port);
197
198         mutex_lock(&private->lock);
199         signals = private->line_signals;
200         mutex_unlock(&private->lock);
201
202         res = ((signals & UPD78F0730_DTR) ? TIOCM_DTR : 0) |
203                 ((signals & UPD78F0730_RTS) ? TIOCM_RTS : 0);
204
205         dev_dbg(dev, "%s - res = %x\n", __func__, res);
206
207         return res;
208 }
209
210 static int upd78f0730_tiocmset(struct tty_struct *tty,
211                         unsigned int set, unsigned int clear)
212 {
213         struct device *dev = tty->dev;
214         struct usb_serial_port *port = tty->driver_data;
215         struct upd78f0730_port_private *private;
216         struct upd78f0730_set_dtr_rts request;
217         int res;
218
219         private = usb_get_serial_port_data(port);
220
221         mutex_lock(&private->lock);
222         if (set & TIOCM_DTR) {
223                 private->line_signals |= UPD78F0730_DTR;
224                 dev_dbg(dev, "%s - set DTR\n", __func__);
225         }
226         if (set & TIOCM_RTS) {
227                 private->line_signals |= UPD78F0730_RTS;
228                 dev_dbg(dev, "%s - set RTS\n", __func__);
229         }
230         if (clear & TIOCM_DTR) {
231                 private->line_signals &= ~UPD78F0730_DTR;
232                 dev_dbg(dev, "%s - clear DTR\n", __func__);
233         }
234         if (clear & TIOCM_RTS) {
235                 private->line_signals &= ~UPD78F0730_RTS;
236                 dev_dbg(dev, "%s - clear RTS\n", __func__);
237         }
238         request.opcode = UPD78F0730_CMD_SET_DTR_RTS;
239         request.params = private->line_signals;
240
241         res = upd78f0730_send_ctl(port, &request, sizeof(request));
242         mutex_unlock(&private->lock);
243
244         return res;
245 }
246
247 static void upd78f0730_break_ctl(struct tty_struct *tty, int break_state)
248 {
249         struct device *dev = tty->dev;
250         struct upd78f0730_port_private *private;
251         struct usb_serial_port *port = tty->driver_data;
252         struct upd78f0730_set_dtr_rts request;
253
254         private = usb_get_serial_port_data(port);
255
256         mutex_lock(&private->lock);
257         if (break_state) {
258                 private->line_signals |= UPD78F0730_BREAK;
259                 dev_dbg(dev, "%s - set BREAK\n", __func__);
260         } else {
261                 private->line_signals &= ~UPD78F0730_BREAK;
262                 dev_dbg(dev, "%s - clear BREAK\n", __func__);
263         }
264         request.opcode = UPD78F0730_CMD_SET_DTR_RTS;
265         request.params = private->line_signals;
266
267         upd78f0730_send_ctl(port, &request, sizeof(request));
268         mutex_unlock(&private->lock);
269 }
270
271 static void upd78f0730_dtr_rts(struct usb_serial_port *port, int on)
272 {
273         struct tty_struct *tty = port->port.tty;
274         unsigned int set = 0;
275         unsigned int clear = 0;
276
277         if (on)
278                 set = TIOCM_DTR | TIOCM_RTS;
279         else
280                 clear = TIOCM_DTR | TIOCM_RTS;
281
282         upd78f0730_tiocmset(tty, set, clear);
283 }
284
285 static speed_t upd78f0730_get_baud_rate(struct tty_struct *tty)
286 {
287         const speed_t baud_rate = tty_get_baud_rate(tty);
288         static const speed_t supported[] = {
289                 0, 2400, 4800, 9600, 19200, 38400, 57600, 115200, 153600
290         };
291         int i;
292
293         for (i = ARRAY_SIZE(supported) - 1; i >= 0; i--) {
294                 if (baud_rate == supported[i])
295                         return baud_rate;
296         }
297
298         /* If the baud rate is not supported, switch to the default one */
299         tty_encode_baud_rate(tty, 9600, 9600);
300
301         return tty_get_baud_rate(tty);
302 }
303
304 static void upd78f0730_set_termios(struct tty_struct *tty,
305                                 struct usb_serial_port *port,
306                                 struct ktermios *old_termios)
307 {
308         struct device *dev = &port->dev;
309         struct upd78f0730_line_control request;
310         speed_t baud_rate;
311
312         if (old_termios && !tty_termios_hw_change(&tty->termios, old_termios))
313                 return;
314
315         if (C_BAUD(tty) == B0)
316                 upd78f0730_dtr_rts(port, 0);
317         else if (old_termios && (old_termios->c_cflag & CBAUD) == B0)
318                 upd78f0730_dtr_rts(port, 1);
319
320         baud_rate = upd78f0730_get_baud_rate(tty);
321         request.opcode = UPD78F0730_CMD_LINE_CONTROL;
322         request.baud_rate = cpu_to_le32(baud_rate);
323         request.params = 0;
324         dev_dbg(dev, "%s - baud rate = %d\n", __func__, baud_rate);
325
326         switch (C_CSIZE(tty)) {
327         case CS7:
328                 request.params |= UPD78F0730_DATA_SIZE_7_BITS;
329                 dev_dbg(dev, "%s - 7 data bits\n", __func__);
330                 break;
331         default:
332                 tty->termios.c_cflag &= ~CSIZE;
333                 tty->termios.c_cflag |= CS8;
334                 dev_warn(dev, "data size is not supported, using 8 bits\n");
335                 /* fall through */
336         case CS8:
337                 request.params |= UPD78F0730_DATA_SIZE_8_BITS;
338                 dev_dbg(dev, "%s - 8 data bits\n", __func__);
339                 break;
340         }
341
342         if (C_PARENB(tty)) {
343                 if (C_PARODD(tty)) {
344                         request.params |= UPD78F0730_PARITY_ODD;
345                         dev_dbg(dev, "%s - odd parity\n", __func__);
346                 } else {
347                         request.params |= UPD78F0730_PARITY_EVEN;
348                         dev_dbg(dev, "%s - even parity\n", __func__);
349                 }
350
351                 if (C_CMSPAR(tty)) {
352                         tty->termios.c_cflag &= ~CMSPAR;
353                         dev_warn(dev, "MARK/SPACE parity is not supported\n");
354                 }
355         } else {
356                 request.params |= UPD78F0730_PARITY_NONE;
357                 dev_dbg(dev, "%s - no parity\n", __func__);
358         }
359
360         if (C_CSTOPB(tty)) {
361                 request.params |= UPD78F0730_STOP_BIT_2_BIT;
362                 dev_dbg(dev, "%s - 2 stop bits\n", __func__);
363         } else {
364                 request.params |= UPD78F0730_STOP_BIT_1_BIT;
365                 dev_dbg(dev, "%s - 1 stop bit\n", __func__);
366         }
367
368         if (C_CRTSCTS(tty)) {
369                 tty->termios.c_cflag &= ~CRTSCTS;
370                 dev_warn(dev, "RTSCTS flow control is not supported\n");
371         }
372         if (I_IXOFF(tty) || I_IXON(tty)) {
373                 tty->termios.c_iflag &= ~(IXOFF | IXON);
374                 dev_warn(dev, "XON/XOFF flow control is not supported\n");
375         }
376         request.params |= UPD78F0730_FLOW_CONTROL_NONE;
377         dev_dbg(dev, "%s - no flow control\n", __func__);
378
379         upd78f0730_send_ctl(port, &request, sizeof(request));
380 }
381
382 static int upd78f0730_open(struct tty_struct *tty, struct usb_serial_port *port)
383 {
384         static const struct upd78f0730_open_close request = {
385                 .opcode = UPD78F0730_CMD_OPEN_CLOSE,
386                 .state = UPD78F0730_PORT_OPEN
387         };
388         int res;
389
390         res = upd78f0730_send_ctl(port, &request, sizeof(request));
391         if (res)
392                 return res;
393
394         if (tty)
395                 upd78f0730_set_termios(tty, port, NULL);
396
397         return usb_serial_generic_open(tty, port);
398 }
399
400 static void upd78f0730_close(struct usb_serial_port *port)
401 {
402         static const struct upd78f0730_open_close request = {
403                 .opcode = UPD78F0730_CMD_OPEN_CLOSE,
404                 .state = UPD78F0730_PORT_CLOSE
405         };
406
407         usb_serial_generic_close(port);
408         upd78f0730_send_ctl(port, &request, sizeof(request));
409 }
410
411 static struct usb_serial_driver upd78f0730_device = {
412         .driver  = {
413                 .owner  = THIS_MODULE,
414                 .name   = "upd78f0730",
415         },
416         .id_table       = id_table,
417         .num_ports      = 1,
418         .port_probe     = upd78f0730_port_probe,
419         .port_remove    = upd78f0730_port_remove,
420         .open           = upd78f0730_open,
421         .close          = upd78f0730_close,
422         .set_termios    = upd78f0730_set_termios,
423         .tiocmget       = upd78f0730_tiocmget,
424         .tiocmset       = upd78f0730_tiocmset,
425         .dtr_rts        = upd78f0730_dtr_rts,
426         .break_ctl      = upd78f0730_break_ctl,
427 };
428
429 static struct usb_serial_driver * const serial_drivers[] = {
430         &upd78f0730_device,
431         NULL
432 };
433
434 module_usb_serial_driver(serial_drivers, id_table);
435
436 MODULE_DESCRIPTION(DRIVER_DESC);
437 MODULE_AUTHOR(DRIVER_AUTHOR);
438 MODULE_LICENSE("GPL v2");