1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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
31static const struct usb_device_id id_table[] = {
32 { USB_DEVICE(0x0409, 0x0063) },
33 { USB_DEVICE(0x045B, 0x0212) },
34 { USB_DEVICE(0x064B, 0x7825) },
35 {}
36};
37
38MODULE_DEVICE_TABLE(usb, id_table);
39
40
41
42
43
44struct upd78f0730_port_private {
45 struct mutex lock;
46 u8 line_signals;
47};
48
49
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
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
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
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
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
79#define UPD78F0730_RTS 0x01
80#define UPD78F0730_DTR 0x02
81#define UPD78F0730_BREAK 0x04
82
83
84#define UPD78F0730_PORT_CLOSE 0x00
85#define UPD78F0730_PORT_OPEN 0x01
86
87
88#define UPD78F0730_ERR_CHR_DISABLED 0x00
89#define UPD78F0730_ERR_CHR_ENABLED 0x01
90
91
92
93
94
95
96struct upd78f0730_line_control {
97 u8 opcode;
98 __le32 baud_rate;
99 u8 params;
100} __packed;
101
102
103struct upd78f0730_set_dtr_rts {
104 u8 opcode;
105 u8 params;
106};
107
108
109struct upd78f0730_set_xon_xoff_chr {
110 u8 opcode;
111 u8 xon;
112 u8 xoff;
113};
114
115
116struct upd78f0730_open_close {
117 u8 opcode;
118 u8 state;
119};
120
121
122struct upd78f0730_set_err_chr {
123 u8 opcode;
124 u8 state;
125 u8 err_char;
126};
127
128static 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
154 if (res >= 0)
155 res = -EIO;
156
157 return res;
158 }
159
160 return 0;
161}
162
163static 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
177static 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
188static 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
210static 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
247static 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
271static 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
285static 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
299 tty_encode_baud_rate(tty, 9600, 9600);
300
301 return tty_get_baud_rate(tty);
302}
303
304static 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 fallthrough;
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
382static 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
400static 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
411static 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
429static struct usb_serial_driver * const serial_drivers[] = {
430 &upd78f0730_device,
431 NULL
432};
433
434module_usb_serial_driver(serial_drivers, id_table);
435
436MODULE_DESCRIPTION(DRIVER_DESC);
437MODULE_AUTHOR(DRIVER_AUTHOR);
438MODULE_LICENSE("GPL v2");
439
