1
2
3
4
5
6
7
8
9
10
11
12#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
13
14#include <linux/kernel.h>
15#include <linux/errno.h>
16#include <linux/module.h>
17#include <linux/sched/signal.h>
18#include <linux/wait.h>
19#include <linux/slab.h>
20#include <linux/uaccess.h>
21#include <linux/mutex.h>
22#include <linux/tty.h>
23#include <linux/serial.h>
24#include <linux/tty_driver.h>
25#include <linux/tty_flip.h>
26#include <linux/idr.h>
27#include <linux/fs.h>
28#include <linux/kdev_t.h>
29#include <linux/kfifo.h>
30#include <linux/workqueue.h>
31#include <linux/completion.h>
32
33#include "greybus.h"
34#include "gbphy.h"
35
36#define GB_NUM_MINORS 16
37#define GB_NAME "ttyGB"
38
39#define GB_UART_WRITE_FIFO_SIZE PAGE_SIZE
40#define GB_UART_WRITE_ROOM_MARGIN 1
41#define GB_UART_FIRMWARE_CREDITS 4096
42#define GB_UART_CREDIT_WAIT_TIMEOUT_MSEC 10000
43
44struct gb_tty_line_coding {
45 __le32 rate;
46 __u8 format;
47 __u8 parity;
48 __u8 data_bits;
49 __u8 flow_control;
50};
51
52struct gb_tty {
53 struct gbphy_device *gbphy_dev;
54 struct tty_port port;
55 void *buffer;
56 size_t buffer_payload_max;
57 struct gb_connection *connection;
58 u16 cport_id;
59 unsigned int minor;
60 unsigned char clocal;
61 bool disconnected;
62 spinlock_t read_lock;
63 spinlock_t write_lock;
64 struct async_icount iocount;
65 struct async_icount oldcount;
66 wait_queue_head_t wioctl;
67 struct mutex mutex;
68 u8 ctrlin;
69 u8 ctrlout;
70 struct gb_tty_line_coding line_coding;
71 struct work_struct tx_work;
72 struct kfifo write_fifo;
73 bool close_pending;
74 unsigned int credits;
75 struct completion credits_complete;
76};
77
78static struct tty_driver *gb_tty_driver;
79static DEFINE_IDR(tty_minors);
80static DEFINE_MUTEX(table_lock);
81
82static int gb_uart_receive_data_handler(struct gb_operation *op)
83{
84 struct gb_connection *connection = op->connection;
85 struct gb_tty *gb_tty = gb_connection_get_data(connection);
86 struct tty_port *port = &gb_tty->port;
87 struct gb_message *request = op->request;
88 struct gb_uart_recv_data_request *receive_data;
89 u16 recv_data_size;
90 int count;
91 unsigned long tty_flags = TTY_NORMAL;
92
93 if (request->payload_size < sizeof(*receive_data)) {
94 dev_err(&gb_tty->gbphy_dev->dev,
95 "short receive-data request received (%zu < %zu)\n",
96 request->payload_size, sizeof(*receive_data));
97 return -EINVAL;
98 }
99
100 receive_data = op->request->payload;
101 recv_data_size = le16_to_cpu(receive_data->size);
102
103 if (recv_data_size != request->payload_size - sizeof(*receive_data)) {
104 dev_err(&gb_tty->gbphy_dev->dev,
105 "malformed receive-data request received (%u != %zu)\n",
106 recv_data_size,
107 request->payload_size - sizeof(*receive_data));
108 return -EINVAL;
109 }
110
111 if (!recv_data_size)
112 return -EINVAL;
113
114 if (receive_data->flags) {
115 if (receive_data->flags & GB_UART_RECV_FLAG_BREAK)
116 tty_flags = TTY_BREAK;
117 else if (receive_data->flags & GB_UART_RECV_FLAG_PARITY)
118 tty_flags = TTY_PARITY;
119 else if (receive_data->flags & GB_UART_RECV_FLAG_FRAMING)
120 tty_flags = TTY_FRAME;
121
122
123 if (receive_data->flags & GB_UART_RECV_FLAG_OVERRUN)
124 tty_insert_flip_char(port, 0, TTY_OVERRUN);
125 }
126 count = tty_insert_flip_string_fixed_flag(port, receive_data->data,
127 tty_flags, recv_data_size);
128 if (count != recv_data_size) {
129 dev_err(&gb_tty->gbphy_dev->dev,
130 "UART: RX 0x%08x bytes only wrote 0x%08x\n",
131 recv_data_size, count);
132 }
133 if (count)
134 tty_flip_buffer_push(port);
135 return 0;
136}
137
138static int gb_uart_serial_state_handler(struct gb_operation *op)
139{
140 struct gb_connection *connection = op->connection;
141 struct gb_tty *gb_tty = gb_connection_get_data(connection);
142 struct gb_message *request = op->request;
143 struct gb_uart_serial_state_request *serial_state;
144
145 if (request->payload_size < sizeof(*serial_state)) {
146 dev_err(&gb_tty->gbphy_dev->dev,
147 "short serial-state event received (%zu < %zu)\n",
148 request->payload_size, sizeof(*serial_state));
149 return -EINVAL;
150 }
151
152 serial_state = request->payload;
153 gb_tty->ctrlin = serial_state->control;
154
155 return 0;
156}
157
158static int gb_uart_receive_credits_handler(struct gb_operation *op)
159{
160 struct gb_connection *connection = op->connection;
161 struct gb_tty *gb_tty = gb_connection_get_data(connection);
162 struct gb_message *request = op->request;
163 struct gb_uart_receive_credits_request *credit_request;
164 unsigned long flags;
165 unsigned int incoming_credits;
166 int ret = 0;
167
168 if (request->payload_size < sizeof(*credit_request)) {
169 dev_err(&gb_tty->gbphy_dev->dev,
170 "short receive_credits event received (%zu < %zu)\n",
171 request->payload_size,
172 sizeof(*credit_request));
173 return -EINVAL;
174 }
175
176 credit_request = request->payload;
177 incoming_credits = le16_to_cpu(credit_request->count);
178
179 spin_lock_irqsave(&gb_tty->write_lock, flags);
180 gb_tty->credits += incoming_credits;
181 if (gb_tty->credits > GB_UART_FIRMWARE_CREDITS) {
182 gb_tty->credits -= incoming_credits;
183 ret = -EINVAL;
184 }
185 spin_unlock_irqrestore(&gb_tty->write_lock, flags);
186
187 if (ret) {
188 dev_err(&gb_tty->gbphy_dev->dev,
189 "invalid number of incoming credits: %d\n",
190 incoming_credits);
191 return ret;
192 }
193
194 if (!gb_tty->close_pending)
195 schedule_work(&gb_tty->tx_work);
196
197
198
199
200 tty_port_tty_wakeup(&gb_tty->port);
201
202 if (gb_tty->credits == GB_UART_FIRMWARE_CREDITS)
203 complete(&gb_tty->credits_complete);
204
205 return ret;
206}
207
208static int gb_uart_request_handler(struct gb_operation *op)
209{
210 struct gb_connection *connection = op->connection;
211 struct gb_tty *gb_tty = gb_connection_get_data(connection);
212 int type = op->type;
213 int ret;
214
215 switch (type) {
216 case GB_UART_TYPE_RECEIVE_DATA:
217 ret = gb_uart_receive_data_handler(op);
218 break;
219 case GB_UART_TYPE_SERIAL_STATE:
220 ret = gb_uart_serial_state_handler(op);
221 break;
222 case GB_UART_TYPE_RECEIVE_CREDITS:
223 ret = gb_uart_receive_credits_handler(op);
224 break;
225 default:
226 dev_err(&gb_tty->gbphy_dev->dev,
227 "unsupported unsolicited request: 0x%02x\n", type);
228 ret = -EINVAL;
229 }
230
231 return ret;
232}
233
234static void gb_uart_tx_write_work(struct work_struct *work)
235{
236 struct gb_uart_send_data_request *request;
237 struct gb_tty *gb_tty;
238 unsigned long flags;
239 unsigned int send_size;
240 int ret;
241
242 gb_tty = container_of(work, struct gb_tty, tx_work);
243 request = gb_tty->buffer;
244
245 while (1) {
246 if (gb_tty->close_pending)
247 break;
248
249 spin_lock_irqsave(&gb_tty->write_lock, flags);
250 send_size = gb_tty->buffer_payload_max;
251 if (send_size > gb_tty->credits)
252 send_size = gb_tty->credits;
253
254 send_size = kfifo_out_peek(&gb_tty->write_fifo,
255 &request->data[0],
256 send_size);
257 if (!send_size) {
258 spin_unlock_irqrestore(&gb_tty->write_lock, flags);
259 break;
260 }
261
262 gb_tty->credits -= send_size;
263 spin_unlock_irqrestore(&gb_tty->write_lock, flags);
264
265 request->size = cpu_to_le16(send_size);
266 ret = gb_operation_sync(gb_tty->connection,
267 GB_UART_TYPE_SEND_DATA,
268 request, sizeof(*request) + send_size,
269 NULL, 0);
270 if (ret) {
271 dev_err(&gb_tty->gbphy_dev->dev,
272 "send data error: %d\n", ret);
273 spin_lock_irqsave(&gb_tty->write_lock, flags);
274 gb_tty->credits += send_size;
275 spin_unlock_irqrestore(&gb_tty->write_lock, flags);
276 if (!gb_tty->close_pending)
277 schedule_work(work);
278 return;
279 }
280
281 spin_lock_irqsave(&gb_tty->write_lock, flags);
282 ret = kfifo_out(&gb_tty->write_fifo, &request->data[0],
283 send_size);
284 spin_unlock_irqrestore(&gb_tty->write_lock, flags);
285
286 tty_port_tty_wakeup(&gb_tty->port);
287 }
288}
289
290static int send_line_coding(struct gb_tty *tty)
291{
292 struct gb_uart_set_line_coding_request request;
293
294 memcpy(&request, &tty->line_coding,
295 sizeof(tty->line_coding));
296 return gb_operation_sync(tty->connection, GB_UART_TYPE_SET_LINE_CODING,
297 &request, sizeof(request), NULL, 0);
298}
299
300static int send_control(struct gb_tty *gb_tty, u8 control)
301{
302 struct gb_uart_set_control_line_state_request request;
303
304 request.control = control;
305 return gb_operation_sync(gb_tty->connection,
306 GB_UART_TYPE_SET_CONTROL_LINE_STATE,
307 &request, sizeof(request), NULL, 0);
308}
309
310static int send_break(struct gb_tty *gb_tty, u8 state)
311{
312 struct gb_uart_set_break_request request;
313
314 if ((state != 0) && (state != 1)) {
315 dev_err(&gb_tty->gbphy_dev->dev,
316 "invalid break state of %d\n", state);
317 return -EINVAL;
318 }
319
320 request.state = state;
321 return gb_operation_sync(gb_tty->connection, GB_UART_TYPE_SEND_BREAK,
322 &request, sizeof(request), NULL, 0);
323}
324
325static int gb_uart_wait_for_all_credits(struct gb_tty *gb_tty)
326{
327 int ret;
328
329 if (gb_tty->credits == GB_UART_FIRMWARE_CREDITS)
330 return 0;
331
332 ret = wait_for_completion_timeout(&gb_tty->credits_complete,
333 msecs_to_jiffies(GB_UART_CREDIT_WAIT_TIMEOUT_MSEC));
334 if (!ret) {
335 dev_err(&gb_tty->gbphy_dev->dev,
336 "time out waiting for credits\n");
337 return -ETIMEDOUT;
338 }
339
340 return 0;
341}
342
343static int gb_uart_flush(struct gb_tty *gb_tty, u8 flags)
344{
345 struct gb_uart_serial_flush_request request;
346
347 request.flags = flags;
348 return gb_operation_sync(gb_tty->connection, GB_UART_TYPE_FLUSH_FIFOS,
349 &request, sizeof(request), NULL, 0);
350}
351
352static struct gb_tty *get_gb_by_minor(unsigned int minor)
353{
354 struct gb_tty *gb_tty;
355
356 mutex_lock(&table_lock);
357 gb_tty = idr_find(&tty_minors, minor);
358 if (gb_tty) {
359 mutex_lock(&gb_tty->mutex);
360 if (gb_tty->disconnected) {
361 mutex_unlock(&gb_tty->mutex);
362 gb_tty = NULL;
363 } else {
364 tty_port_get(&gb_tty->port);
365 mutex_unlock(&gb_tty->mutex);
366 }
367 }
368 mutex_unlock(&table_lock);
369 return gb_tty;
370}
371
372static int alloc_minor(struct gb_tty *gb_tty)
373{
374 int minor;
375
376 mutex_lock(&table_lock);
377 minor = idr_alloc(&tty_minors, gb_tty, 0, GB_NUM_MINORS, GFP_KERNEL);
378 mutex_unlock(&table_lock);
379 if (minor >= 0)
380 gb_tty->minor = minor;
381 return minor;
382}
383
384static void release_minor(struct gb_tty *gb_tty)
385{
386 int minor = gb_tty->minor;
387
388 gb_tty->minor = 0;
389 mutex_lock(&table_lock);
390 idr_remove(&tty_minors, minor);
391 mutex_unlock(&table_lock);
392}
393
394static int gb_tty_install(struct tty_driver *driver, struct tty_struct *tty)
395{
396 struct gb_tty *gb_tty;
397 int retval;
398
399 gb_tty = get_gb_by_minor(tty->index);
400 if (!gb_tty)
401 return -ENODEV;
402
403 retval = tty_standard_install(driver, tty);
404 if (retval)
405 goto error;
406
407 tty->driver_data = gb_tty;
408 return 0;
409error:
410 tty_port_put(&gb_tty->port);
411 return retval;
412}
413
414static int gb_tty_open(struct tty_struct *tty, struct file *file)
415{
416 struct gb_tty *gb_tty = tty->driver_data;
417
418 return tty_port_open(&gb_tty->port, tty, file);
419}
420
421static void gb_tty_close(struct tty_struct *tty, struct file *file)
422{
423 struct gb_tty *gb_tty = tty->driver_data;
424
425 tty_port_close(&gb_tty->port, tty, file);
426}
427
428static void gb_tty_cleanup(struct tty_struct *tty)
429{
430 struct gb_tty *gb_tty = tty->driver_data;
431
432 tty_port_put(&gb_tty->port);
433}
434
435static void gb_tty_hangup(struct tty_struct *tty)
436{
437 struct gb_tty *gb_tty = tty->driver_data;
438
439 tty_port_hangup(&gb_tty->port);
440}
441
442static int gb_tty_write(struct tty_struct *tty, const unsigned char *buf,
443 int count)
444{
445 struct gb_tty *gb_tty = tty->driver_data;
446
447 count = kfifo_in_spinlocked(&gb_tty->write_fifo, buf, count,
448 &gb_tty->write_lock);
449 if (count && !gb_tty->close_pending)
450 schedule_work(&gb_tty->tx_work);
451
452 return count;
453}
454
455static int gb_tty_write_room(struct tty_struct *tty)
456{
457 struct gb_tty *gb_tty = tty->driver_data;
458 unsigned long flags;
459 int room;
460
461 spin_lock_irqsave(&gb_tty->write_lock, flags);
462 room = kfifo_avail(&gb_tty->write_fifo);
463 spin_unlock_irqrestore(&gb_tty->write_lock, flags);
464
465 room -= GB_UART_WRITE_ROOM_MARGIN;
466 if (room < 0)
467 return 0;
468
469 return room;
470}
471
472static int gb_tty_chars_in_buffer(struct tty_struct *tty)
473{
474 struct gb_tty *gb_tty = tty->driver_data;
475 unsigned long flags;
476 int chars;
477
478 spin_lock_irqsave(&gb_tty->write_lock, flags);
479 chars = kfifo_len(&gb_tty->write_fifo);
480 if (gb_tty->credits < GB_UART_FIRMWARE_CREDITS)
481 chars += GB_UART_FIRMWARE_CREDITS - gb_tty->credits;
482 spin_unlock_irqrestore(&gb_tty->write_lock, flags);
483
484 return chars;
485}
486
487static int gb_tty_break_ctl(struct tty_struct *tty, int state)
488{
489 struct gb_tty *gb_tty = tty->driver_data;
490
491 return send_break(gb_tty, state ? 1 : 0);
492}
493
494static void gb_tty_set_termios(struct tty_struct *tty,
495 struct ktermios *termios_old)
496{
497 struct gb_tty *gb_tty = tty->driver_data;
498 struct ktermios *termios = &tty->termios;
499 struct gb_tty_line_coding newline;
500 u8 newctrl = gb_tty->ctrlout;
501
502 newline.rate = cpu_to_le32(tty_get_baud_rate(tty));
503 newline.format = termios->c_cflag & CSTOPB ?
504 GB_SERIAL_2_STOP_BITS : GB_SERIAL_1_STOP_BITS;
505 newline.parity = termios->c_cflag & PARENB ?
506 (termios->c_cflag & PARODD ? 1 : 2) +
507 (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
508
509 switch (termios->c_cflag & CSIZE) {
510 case CS5:
511 newline.data_bits = 5;
512 break;
513 case CS6:
514 newline.data_bits = 6;
515 break;
516 case CS7:
517 newline.data_bits = 7;
518 break;
519 case CS8:
520 default:
521 newline.data_bits = 8;
522 break;
523 }
524
525
526 gb_tty->clocal = ((termios->c_cflag & CLOCAL) != 0);
527
528 if (C_BAUD(tty) == B0) {
529 newline.rate = gb_tty->line_coding.rate;
530 newctrl &= ~(GB_UART_CTRL_DTR | GB_UART_CTRL_RTS);
531 } else if (termios_old && (termios_old->c_cflag & CBAUD) == B0) {
532 newctrl |= (GB_UART_CTRL_DTR | GB_UART_CTRL_RTS);
533 }
534
535 if (newctrl != gb_tty->ctrlout) {
536 gb_tty->ctrlout = newctrl;
537 send_control(gb_tty, newctrl);
538 }
539
540 if (C_CRTSCTS(tty) && C_BAUD(tty) != B0)
541 newline.flow_control |= GB_SERIAL_AUTO_RTSCTS_EN;
542 else
543 newline.flow_control &= ~GB_SERIAL_AUTO_RTSCTS_EN;
544
545 if (memcmp(&gb_tty->line_coding, &newline, sizeof(newline))) {
546 memcpy(&gb_tty->line_coding, &newline, sizeof(newline));
547 send_line_coding(gb_tty);
548 }
549}
550
551static int gb_tty_tiocmget(struct tty_struct *tty)
552{
553 struct gb_tty *gb_tty = tty->driver_data;
554
555 return (gb_tty->ctrlout & GB_UART_CTRL_DTR ? TIOCM_DTR : 0) |
556 (gb_tty->ctrlout & GB_UART_CTRL_RTS ? TIOCM_RTS : 0) |
557 (gb_tty->ctrlin & GB_UART_CTRL_DSR ? TIOCM_DSR : 0) |
558 (gb_tty->ctrlin & GB_UART_CTRL_RI ? TIOCM_RI : 0) |
559 (gb_tty->ctrlin & GB_UART_CTRL_DCD ? TIOCM_CD : 0) |
560 TIOCM_CTS;
561}
562
563static int gb_tty_tiocmset(struct tty_struct *tty, unsigned int set,
564 unsigned int clear)
565{
566 struct gb_tty *gb_tty = tty->driver_data;
567 u8 newctrl = gb_tty->ctrlout;
568
569 set = (set & TIOCM_DTR ? GB_UART_CTRL_DTR : 0) |
570 (set & TIOCM_RTS ? GB_UART_CTRL_RTS : 0);
571 clear = (clear & TIOCM_DTR ? GB_UART_CTRL_DTR : 0) |
572 (clear & TIOCM_RTS ? GB_UART_CTRL_RTS : 0);
573
574 newctrl = (newctrl & ~clear) | set;
575 if (gb_tty->ctrlout == newctrl)
576 return 0;
577
578 gb_tty->ctrlout = newctrl;
579 return send_control(gb_tty, newctrl);
580}
581
582static void gb_tty_throttle(struct tty_struct *tty)
583{
584 struct gb_tty *gb_tty = tty->driver_data;
585 unsigned char stop_char;
586 int retval;
587
588 if (I_IXOFF(tty)) {
589 stop_char = STOP_CHAR(tty);
590 retval = gb_tty_write(tty, &stop_char, 1);
591 if (retval <= 0)
592 return;
593 }
594
595 if (tty->termios.c_cflag & CRTSCTS) {
596 gb_tty->ctrlout &= ~GB_UART_CTRL_RTS;
597 retval = send_control(gb_tty, gb_tty->ctrlout);
598 }
599}
600
601static void gb_tty_unthrottle(struct tty_struct *tty)
602{
603 struct gb_tty *gb_tty = tty->driver_data;
604 unsigned char start_char;
605 int retval;
606
607 if (I_IXOFF(tty)) {
608 start_char = START_CHAR(tty);
609 retval = gb_tty_write(tty, &start_char, 1);
610 if (retval <= 0)
611 return;
612 }
613
614 if (tty->termios.c_cflag & CRTSCTS) {
615 gb_tty->ctrlout |= GB_UART_CTRL_RTS;
616 retval = send_control(gb_tty, gb_tty->ctrlout);
617 }
618}
619
620static int get_serial_info(struct gb_tty *gb_tty,
621 struct serial_struct __user *info)
622{
623 struct serial_struct tmp;
624
625 memset(&tmp, 0, sizeof(tmp));
626 tmp.type = PORT_16550A;
627 tmp.line = gb_tty->minor;
628 tmp.xmit_fifo_size = 16;
629 tmp.baud_base = 9600;
630 tmp.close_delay = gb_tty->port.close_delay / 10;
631 tmp.closing_wait =
632 gb_tty->port.closing_wait == ASYNC_CLOSING_WAIT_NONE ?
633 ASYNC_CLOSING_WAIT_NONE : gb_tty->port.closing_wait / 10;
634
635 if (copy_to_user(info, &tmp, sizeof(tmp)))
636 return -EFAULT;
637 return 0;
638}
639
640static int set_serial_info(struct gb_tty *gb_tty,
641 struct serial_struct __user *newinfo)
642{
643 struct serial_struct new_serial;
644 unsigned int closing_wait;
645 unsigned int close_delay;
646 int retval = 0;
647
648 if (copy_from_user(&new_serial, newinfo, sizeof(new_serial)))
649 return -EFAULT;
650
651 close_delay = new_serial.close_delay * 10;
652 closing_wait = new_serial.closing_wait == ASYNC_CLOSING_WAIT_NONE ?
653 ASYNC_CLOSING_WAIT_NONE : new_serial.closing_wait * 10;
654
655 mutex_lock(&gb_tty->port.mutex);
656 if (!capable(CAP_SYS_ADMIN)) {
657 if ((close_delay != gb_tty->port.close_delay) ||
658 (closing_wait != gb_tty->port.closing_wait))
659 retval = -EPERM;
660 else
661 retval = -EOPNOTSUPP;
662 } else {
663 gb_tty->port.close_delay = close_delay;
664 gb_tty->port.closing_wait = closing_wait;
665 }
666 mutex_unlock(&gb_tty->port.mutex);
667 return retval;
668}
669
670static int wait_serial_change(struct gb_tty *gb_tty, unsigned long arg)
671{
672 int retval = 0;
673 DECLARE_WAITQUEUE(wait, current);
674 struct async_icount old;
675 struct async_icount new;
676
677 if (!(arg & (TIOCM_DSR | TIOCM_RI | TIOCM_CD)))
678 return -EINVAL;
679
680 do {
681 spin_lock_irq(&gb_tty->read_lock);
682 old = gb_tty->oldcount;
683 new = gb_tty->iocount;
684 gb_tty->oldcount = new;
685 spin_unlock_irq(&gb_tty->read_lock);
686
687 if ((arg & TIOCM_DSR) && (old.dsr != new.dsr))
688 break;
689 if ((arg & TIOCM_CD) && (old.dcd != new.dcd))
690 break;
691 if ((arg & TIOCM_RI) && (old.rng != new.rng))
692 break;
693
694 add_wait_queue(&gb_tty->wioctl, &wait);
695 set_current_state(TASK_INTERRUPTIBLE);
696 schedule();
697 remove_wait_queue(&gb_tty->wioctl, &wait);
698 if (gb_tty->disconnected) {
699 if (arg & TIOCM_CD)
700 break;
701 retval = -ENODEV;
702 } else if (signal_pending(current)) {
703 retval = -ERESTARTSYS;
704 }
705 } while (!retval);
706
707 return retval;
708}
709
710static int gb_tty_get_icount(struct tty_struct *tty,
711 struct serial_icounter_struct *icount)
712{
713 struct gb_tty *gb_tty = tty->driver_data;
714
715 icount->dsr = gb_tty->iocount.dsr;
716 icount->rng = gb_tty->iocount.rng;
717 icount->dcd = gb_tty->iocount.dcd;
718 icount->frame = gb_tty->iocount.frame;
719 icount->overrun = gb_tty->iocount.overrun;
720 icount->parity = gb_tty->iocount.parity;
721 icount->brk = gb_tty->iocount.brk;
722
723 return 0;
724}
725
726static int gb_tty_ioctl(struct tty_struct *tty, unsigned int cmd,
727 unsigned long arg)
728{
729 struct gb_tty *gb_tty = tty->driver_data;
730
731 switch (cmd) {
732 case TIOCGSERIAL:
733 return get_serial_info(gb_tty,
734 (struct serial_struct __user *)arg);
735 case TIOCSSERIAL:
736 return set_serial_info(gb_tty,
737 (struct serial_struct __user *)arg);
738 case TIOCMIWAIT:
739 return wait_serial_change(gb_tty, arg);
740 }
741
742 return -ENOIOCTLCMD;
743}
744
745static void gb_tty_dtr_rts(struct tty_port *port, int on)
746{
747 struct gb_tty *gb_tty;
748 u8 newctrl;
749
750 gb_tty = container_of(port, struct gb_tty, port);
751 newctrl = gb_tty->ctrlout;
752
753 if (on)
754 newctrl |= (GB_UART_CTRL_DTR | GB_UART_CTRL_RTS);
755 else
756 newctrl &= ~(GB_UART_CTRL_DTR | GB_UART_CTRL_RTS);
757
758 gb_tty->ctrlout = newctrl;
759 send_control(gb_tty, newctrl);
760}
761
762static int gb_tty_port_activate(struct tty_port *port,
763 struct tty_struct *tty)
764{
765 struct gb_tty *gb_tty;
766
767 gb_tty = container_of(port, struct gb_tty, port);
768
769 return gbphy_runtime_get_sync(gb_tty->gbphy_dev);
770}
771
772static void gb_tty_port_shutdown(struct tty_port *port)
773{
774 struct gb_tty *gb_tty;
775 unsigned long flags;
776 int ret;
777
778 gb_tty = container_of(port, struct gb_tty, port);
779
780 gb_tty->close_pending = true;
781
782 cancel_work_sync(&gb_tty->tx_work);
783
784 spin_lock_irqsave(&gb_tty->write_lock, flags);
785 kfifo_reset_out(&gb_tty->write_fifo);
786 spin_unlock_irqrestore(&gb_tty->write_lock, flags);
787
788 if (gb_tty->credits == GB_UART_FIRMWARE_CREDITS)
789 goto out;
790
791 ret = gb_uart_flush(gb_tty, GB_SERIAL_FLAG_FLUSH_TRANSMITTER);
792 if (ret) {
793 dev_err(&gb_tty->gbphy_dev->dev,
794 "error flushing transmitter: %d\n", ret);
795 }
796
797 gb_uart_wait_for_all_credits(gb_tty);
798
799out:
800 gb_tty->close_pending = false;
801
802 gbphy_runtime_put_autosuspend(gb_tty->gbphy_dev);
803}
804
805static const struct tty_operations gb_ops = {
806 .install = gb_tty_install,
807 .open = gb_tty_open,
808 .close = gb_tty_close,
809 .cleanup = gb_tty_cleanup,
810 .hangup = gb_tty_hangup,
811 .write = gb_tty_write,
812 .write_room = gb_tty_write_room,
813 .ioctl = gb_tty_ioctl,
814 .throttle = gb_tty_throttle,
815 .unthrottle = gb_tty_unthrottle,
816 .chars_in_buffer = gb_tty_chars_in_buffer,
817 .break_ctl = gb_tty_break_ctl,
818 .set_termios = gb_tty_set_termios,
819 .tiocmget = gb_tty_tiocmget,
820 .tiocmset = gb_tty_tiocmset,
821 .get_icount = gb_tty_get_icount,
822};
823
824static const struct tty_port_operations gb_port_ops = {
825 .dtr_rts = gb_tty_dtr_rts,
826 .activate = gb_tty_port_activate,
827 .shutdown = gb_tty_port_shutdown,
828};
829
830static int gb_uart_probe(struct gbphy_device *gbphy_dev,
831 const struct gbphy_device_id *id)
832{
833 struct gb_connection *connection;
834 size_t max_payload;
835 struct gb_tty *gb_tty;
836 struct device *tty_dev;
837 int retval;
838 int minor;
839
840 gb_tty = kzalloc(sizeof(*gb_tty), GFP_KERNEL);
841 if (!gb_tty)
842 return -ENOMEM;
843
844 connection = gb_connection_create(gbphy_dev->bundle,
845 le16_to_cpu(gbphy_dev->cport_desc->id),
846 gb_uart_request_handler);
847 if (IS_ERR(connection)) {
848 retval = PTR_ERR(connection);
849 goto exit_tty_free;
850 }
851
852 max_payload = gb_operation_get_payload_size_max(connection);
853 if (max_payload < sizeof(struct gb_uart_send_data_request)) {
854 retval = -EINVAL;
855 goto exit_connection_destroy;
856 }
857
858 gb_tty->buffer_payload_max = max_payload -
859 sizeof(struct gb_uart_send_data_request);
860
861 gb_tty->buffer = kzalloc(gb_tty->buffer_payload_max, GFP_KERNEL);
862 if (!gb_tty->buffer) {
863 retval = -ENOMEM;
864 goto exit_connection_destroy;
865 }
866
867 INIT_WORK(&gb_tty->tx_work, gb_uart_tx_write_work);
868
869 retval = kfifo_alloc(&gb_tty->write_fifo, GB_UART_WRITE_FIFO_SIZE,
870 GFP_KERNEL);
871 if (retval)
872 goto exit_buf_free;
873
874 gb_tty->credits = GB_UART_FIRMWARE_CREDITS;
875 init_completion(&gb_tty->credits_complete);
876
877 minor = alloc_minor(gb_tty);
878 if (minor < 0) {
879 if (minor == -ENOSPC) {
880 dev_err(&gbphy_dev->dev,
881 "no more free minor numbers\n");
882 retval = -ENODEV;
883 } else {
884 retval = minor;
885 }
886 goto exit_kfifo_free;
887 }
888
889 gb_tty->minor = minor;
890 spin_lock_init(&gb_tty->write_lock);
891 spin_lock_init(&gb_tty->read_lock);
892 init_waitqueue_head(&gb_tty->wioctl);
893 mutex_init(&gb_tty->mutex);
894
895 tty_port_init(&gb_tty->port);
896 gb_tty->port.ops = &gb_port_ops;
897
898 gb_tty->connection = connection;
899 gb_tty->gbphy_dev = gbphy_dev;
900 gb_connection_set_data(connection, gb_tty);
901 gb_gbphy_set_data(gbphy_dev, gb_tty);
902
903 retval = gb_connection_enable_tx(connection);
904 if (retval)
905 goto exit_release_minor;
906
907 send_control(gb_tty, gb_tty->ctrlout);
908
909
910 gb_tty->line_coding.rate = cpu_to_le32(9600);
911 gb_tty->line_coding.format = GB_SERIAL_1_STOP_BITS;
912 gb_tty->line_coding.parity = GB_SERIAL_NO_PARITY;
913 gb_tty->line_coding.data_bits = 8;
914 send_line_coding(gb_tty);
915
916 retval = gb_connection_enable(connection);
917 if (retval)
918 goto exit_connection_disable;
919
920 tty_dev = tty_port_register_device(&gb_tty->port, gb_tty_driver, minor,
921 &gbphy_dev->dev);
922 if (IS_ERR(tty_dev)) {
923 retval = PTR_ERR(tty_dev);
924 goto exit_connection_disable;
925 }
926
927 gbphy_runtime_put_autosuspend(gbphy_dev);
928 return 0;
929
930exit_connection_disable:
931 gb_connection_disable(connection);
932exit_release_minor:
933 release_minor(gb_tty);
934exit_kfifo_free:
935 kfifo_free(&gb_tty->write_fifo);
936exit_buf_free:
937 kfree(gb_tty->buffer);
938exit_connection_destroy:
939 gb_connection_destroy(connection);
940exit_tty_free:
941 kfree(gb_tty);
942
943 return retval;
944}
945
946static void gb_uart_remove(struct gbphy_device *gbphy_dev)
947{
948 struct gb_tty *gb_tty = gb_gbphy_get_data(gbphy_dev);
949 struct gb_connection *connection = gb_tty->connection;
950 struct tty_struct *tty;
951 int ret;
952
953 ret = gbphy_runtime_get_sync(gbphy_dev);
954 if (ret)
955 gbphy_runtime_get_noresume(gbphy_dev);
956
957 mutex_lock(&gb_tty->mutex);
958 gb_tty->disconnected = true;
959
960 wake_up_all(&gb_tty->wioctl);
961 mutex_unlock(&gb_tty->mutex);
962
963 tty = tty_port_tty_get(&gb_tty->port);
964 if (tty) {
965 tty_vhangup(tty);
966 tty_kref_put(tty);
967 }
968
969 gb_connection_disable_rx(connection);
970 tty_unregister_device(gb_tty_driver, gb_tty->minor);
971
972
973
974 gb_connection_disable(connection);
975 tty_port_destroy(&gb_tty->port);
976 gb_connection_destroy(connection);
977 release_minor(gb_tty);
978 kfifo_free(&gb_tty->write_fifo);
979 kfree(gb_tty->buffer);
980 kfree(gb_tty);
981}
982
983static int gb_tty_init(void)
984{
985 int retval = 0;
986
987 gb_tty_driver = tty_alloc_driver(GB_NUM_MINORS, 0);
988 if (IS_ERR(gb_tty_driver)) {
989 pr_err("Can not allocate tty driver\n");
990 retval = -ENOMEM;
991 goto fail_unregister_dev;
992 }
993
994 gb_tty_driver->driver_name = "gb";
995 gb_tty_driver->name = GB_NAME;
996 gb_tty_driver->major = 0;
997 gb_tty_driver->minor_start = 0;
998 gb_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
999 gb_tty_driver->subtype = SERIAL_TYPE_NORMAL;
1000 gb_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1001 gb_tty_driver->init_termios = tty_std_termios;
1002 gb_tty_driver->init_termios.c_cflag = B9600 | CS8 |
1003 CREAD | HUPCL | CLOCAL;
1004 tty_set_operations(gb_tty_driver, &gb_ops);
1005
1006 retval = tty_register_driver(gb_tty_driver);
1007 if (retval) {
1008 pr_err("Can not register tty driver: %d\n", retval);
1009 goto fail_put_gb_tty;
1010 }
1011
1012 return 0;
1013
1014fail_put_gb_tty:
1015 put_tty_driver(gb_tty_driver);
1016fail_unregister_dev:
1017 return retval;
1018}
1019
1020static void gb_tty_exit(void)
1021{
1022 tty_unregister_driver(gb_tty_driver);
1023 put_tty_driver(gb_tty_driver);
1024 idr_destroy(&tty_minors);
1025}
1026
1027static const struct gbphy_device_id gb_uart_id_table[] = {
1028 { GBPHY_PROTOCOL(GREYBUS_PROTOCOL_UART) },
1029 { },
1030};
1031MODULE_DEVICE_TABLE(gbphy, gb_uart_id_table);
1032
1033static struct gbphy_driver uart_driver = {
1034 .name = "uart",
1035 .probe = gb_uart_probe,
1036 .remove = gb_uart_remove,
1037 .id_table = gb_uart_id_table,
1038};
1039
1040static int gb_uart_driver_init(void)
1041{
1042 int ret;
1043
1044 ret = gb_tty_init();
1045 if (ret)
1046 return ret;
1047
1048 ret = gb_gbphy_register(&uart_driver);
1049 if (ret) {
1050 gb_tty_exit();
1051 return ret;
1052 }
1053
1054 return 0;
1055}
1056module_init(gb_uart_driver_init);
1057
1058static void gb_uart_driver_exit(void)
1059{
1060 gb_gbphy_deregister(&uart_driver);
1061 gb_tty_exit();
1062}
1063
1064module_exit(gb_uart_driver_exit);
1065MODULE_LICENSE("GPL v2");
1066
