2 * UART driver for the Greybus "generic" UART module.
4 * Copyright 2014 Google Inc.
5 * Copyright 2014 Linaro Ltd.
7 * Released under the GPLv2 only.
9 * Heavily based on drivers/usb/class/cdc-acm.c and
10 * drivers/usb/serial/usb-serial.c.
12 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
14 #include <linux/kernel.h>
15 #include <linux/errno.h>
16 #include <linux/module.h>
17 #include <linux/sched.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/serial.h>
27 #include <linux/idr.h>
29 #include <linux/kdev_t.h>
30 #include <linux/kfifo.h>
31 #include <linux/workqueue.h>
32 #include <linux/completion.h>
37 #define GB_NUM_MINORS 16 /* 16 is is more than enough */
38 #define GB_NAME "ttyGB"
40 #define GB_UART_WRITE_FIFO_SIZE PAGE_SIZE
41 #define GB_UART_WRITE_ROOM_MARGIN 1 /* leave some space in fifo */
42 #define GB_UART_FIRMWARE_CREDITS 4096
43 #define GB_UART_CREDIT_WAIT_TIMEOUT_MSEC 10000
45 struct gb_tty_line_coding {
54 struct gbphy_device *gbphy_dev;
57 size_t buffer_payload_max;
58 struct gb_connection *connection;
64 spinlock_t write_lock;
65 struct async_icount iocount;
66 struct async_icount oldcount;
67 wait_queue_head_t wioctl;
69 u8 ctrlin; /* input control lines */
70 u8 ctrlout; /* output control lines */
71 struct gb_tty_line_coding line_coding;
72 struct work_struct tx_work;
73 struct kfifo write_fifo;
76 struct completion credits_complete;
79 static struct tty_driver *gb_tty_driver;
80 static DEFINE_IDR(tty_minors);
81 static DEFINE_MUTEX(table_lock);
83 static int gb_uart_receive_data_handler(struct gb_operation *op)
85 struct gb_connection *connection = op->connection;
86 struct gb_tty *gb_tty = gb_connection_get_data(connection);
87 struct tty_port *port = &gb_tty->port;
88 struct gb_message *request = op->request;
89 struct gb_uart_recv_data_request *receive_data;
92 unsigned long tty_flags = TTY_NORMAL;
94 if (request->payload_size < sizeof(*receive_data)) {
95 dev_err(&gb_tty->gbphy_dev->dev,
96 "short receive-data request received (%zu < %zu)\n",
97 request->payload_size, sizeof(*receive_data));
101 receive_data = op->request->payload;
102 recv_data_size = le16_to_cpu(receive_data->size);
104 if (recv_data_size != request->payload_size - sizeof(*receive_data)) {
105 dev_err(&gb_tty->gbphy_dev->dev,
106 "malformed receive-data request received (%u != %zu)\n",
108 request->payload_size - sizeof(*receive_data));
115 if (receive_data->flags) {
116 if (receive_data->flags & GB_UART_RECV_FLAG_BREAK)
117 tty_flags = TTY_BREAK;
118 else if (receive_data->flags & GB_UART_RECV_FLAG_PARITY)
119 tty_flags = TTY_PARITY;
120 else if (receive_data->flags & GB_UART_RECV_FLAG_FRAMING)
121 tty_flags = TTY_FRAME;
123 /* overrun is special, not associated with a char */
124 if (receive_data->flags & GB_UART_RECV_FLAG_OVERRUN)
125 tty_insert_flip_char(port, 0, TTY_OVERRUN);
127 count = tty_insert_flip_string_fixed_flag(port, receive_data->data,
128 tty_flags, recv_data_size);
129 if (count != recv_data_size) {
130 dev_err(&gb_tty->gbphy_dev->dev,
131 "UART: RX 0x%08x bytes only wrote 0x%08x\n",
132 recv_data_size, count);
135 tty_flip_buffer_push(port);
139 static int gb_uart_serial_state_handler(struct gb_operation *op)
141 struct gb_connection *connection = op->connection;
142 struct gb_tty *gb_tty = gb_connection_get_data(connection);
143 struct gb_message *request = op->request;
144 struct gb_uart_serial_state_request *serial_state;
146 if (request->payload_size < sizeof(*serial_state)) {
147 dev_err(&gb_tty->gbphy_dev->dev,
148 "short serial-state event received (%zu < %zu)\n",
149 request->payload_size, sizeof(*serial_state));
153 serial_state = request->payload;
154 gb_tty->ctrlin = serial_state->control;
159 static int gb_uart_receive_credits_handler(struct gb_operation *op)
161 struct gb_connection *connection = op->connection;
162 struct gb_tty *gb_tty = gb_connection_get_data(connection);
163 struct gb_message *request = op->request;
164 struct gb_uart_receive_credits_request *credit_request;
166 unsigned int incoming_credits;
169 if (request->payload_size < sizeof(*credit_request)) {
170 dev_err(&gb_tty->gbphy_dev->dev,
171 "short receive_credits event received (%zu < %zu)\n",
172 request->payload_size,
173 sizeof(*credit_request));
177 credit_request = request->payload;
178 incoming_credits = le16_to_cpu(credit_request->count);
180 spin_lock_irqsave(&gb_tty->write_lock, flags);
181 gb_tty->credits += incoming_credits;
182 if (gb_tty->credits > GB_UART_FIRMWARE_CREDITS) {
183 gb_tty->credits -= incoming_credits;
186 spin_unlock_irqrestore(&gb_tty->write_lock, flags);
189 dev_err(&gb_tty->gbphy_dev->dev,
190 "invalid number of incoming credits: %d\n",
195 if (!gb_tty->close_pending)
196 schedule_work(&gb_tty->tx_work);
199 * the port the tty layer may be waiting for credits
201 tty_port_tty_wakeup(&gb_tty->port);
203 if (gb_tty->credits == GB_UART_FIRMWARE_CREDITS)
204 complete(&gb_tty->credits_complete);
209 static int gb_uart_request_handler(struct gb_operation *op)
211 struct gb_connection *connection = op->connection;
212 struct gb_tty *gb_tty = gb_connection_get_data(connection);
217 case GB_UART_TYPE_RECEIVE_DATA:
218 ret = gb_uart_receive_data_handler(op);
220 case GB_UART_TYPE_SERIAL_STATE:
221 ret = gb_uart_serial_state_handler(op);
223 case GB_UART_TYPE_RECEIVE_CREDITS:
224 ret = gb_uart_receive_credits_handler(op);
227 dev_err(&gb_tty->gbphy_dev->dev,
228 "unsupported unsolicited request: 0x%02x\n", type);
235 static void gb_uart_tx_write_work(struct work_struct *work)
237 struct gb_uart_send_data_request *request;
238 struct gb_tty *gb_tty;
240 unsigned int send_size;
243 gb_tty = container_of(work, struct gb_tty, tx_work);
244 request = gb_tty->buffer;
247 if (gb_tty->close_pending)
250 spin_lock_irqsave(&gb_tty->write_lock, flags);
251 send_size = gb_tty->buffer_payload_max;
252 if (send_size > gb_tty->credits)
253 send_size = gb_tty->credits;
255 send_size = kfifo_out_peek(&gb_tty->write_fifo,
259 spin_unlock_irqrestore(&gb_tty->write_lock, flags);
263 gb_tty->credits -= send_size;
264 spin_unlock_irqrestore(&gb_tty->write_lock, flags);
266 request->size = cpu_to_le16(send_size);
267 ret = gb_operation_sync(gb_tty->connection,
268 GB_UART_TYPE_SEND_DATA,
269 request, sizeof(*request) + send_size,
272 dev_err(&gb_tty->gbphy_dev->dev,
273 "send data error: %d\n", ret);
274 spin_lock_irqsave(&gb_tty->write_lock, flags);
275 gb_tty->credits += send_size;
276 spin_unlock_irqrestore(&gb_tty->write_lock, flags);
277 if (!gb_tty->close_pending)
282 spin_lock_irqsave(&gb_tty->write_lock, flags);
283 ret = kfifo_out(&gb_tty->write_fifo, &request->data[0],
285 spin_unlock_irqrestore(&gb_tty->write_lock, flags);
287 tty_port_tty_wakeup(&gb_tty->port);
291 static int send_line_coding(struct gb_tty *tty)
293 struct gb_uart_set_line_coding_request request;
295 memcpy(&request, &tty->line_coding,
296 sizeof(tty->line_coding));
297 return gb_operation_sync(tty->connection, GB_UART_TYPE_SET_LINE_CODING,
298 &request, sizeof(request), NULL, 0);
301 static int send_control(struct gb_tty *gb_tty, u8 control)
303 struct gb_uart_set_control_line_state_request request;
305 request.control = control;
306 return gb_operation_sync(gb_tty->connection,
307 GB_UART_TYPE_SET_CONTROL_LINE_STATE,
308 &request, sizeof(request), NULL, 0);
311 static int send_break(struct gb_tty *gb_tty, u8 state)
313 struct gb_uart_set_break_request request;
315 if ((state != 0) && (state != 1)) {
316 dev_err(&gb_tty->gbphy_dev->dev,
317 "invalid break state of %d\n", state);
321 request.state = state;
322 return gb_operation_sync(gb_tty->connection, GB_UART_TYPE_SEND_BREAK,
323 &request, sizeof(request), NULL, 0);
326 static int gb_uart_wait_for_all_credits(struct gb_tty *gb_tty)
330 if (gb_tty->credits == GB_UART_FIRMWARE_CREDITS)
333 ret = wait_for_completion_timeout(&gb_tty->credits_complete,
334 msecs_to_jiffies(GB_UART_CREDIT_WAIT_TIMEOUT_MSEC));
336 dev_err(&gb_tty->gbphy_dev->dev,
337 "time out waiting for credits\n");
344 static int gb_uart_flush(struct gb_tty *gb_tty, u8 flags)
346 struct gb_uart_serial_flush_request request;
348 request.flags = flags;
349 return gb_operation_sync(gb_tty->connection, GB_UART_TYPE_FLUSH_FIFOS,
350 &request, sizeof(request), NULL, 0);
353 static struct gb_tty *get_gb_by_minor(unsigned int minor)
355 struct gb_tty *gb_tty;
357 mutex_lock(&table_lock);
358 gb_tty = idr_find(&tty_minors, minor);
360 mutex_lock(&gb_tty->mutex);
361 if (gb_tty->disconnected) {
362 mutex_unlock(&gb_tty->mutex);
365 tty_port_get(&gb_tty->port);
366 mutex_unlock(&gb_tty->mutex);
369 mutex_unlock(&table_lock);
373 static int alloc_minor(struct gb_tty *gb_tty)
377 mutex_lock(&table_lock);
378 minor = idr_alloc(&tty_minors, gb_tty, 0, GB_NUM_MINORS, GFP_KERNEL);
379 mutex_unlock(&table_lock);
381 gb_tty->minor = minor;
385 static void release_minor(struct gb_tty *gb_tty)
387 int minor = gb_tty->minor;
389 gb_tty->minor = 0; /* Maybe should use an invalid value instead */
390 mutex_lock(&table_lock);
391 idr_remove(&tty_minors, minor);
392 mutex_unlock(&table_lock);
395 static int gb_tty_install(struct tty_driver *driver, struct tty_struct *tty)
397 struct gb_tty *gb_tty;
400 gb_tty = get_gb_by_minor(tty->index);
404 retval = tty_standard_install(driver, tty);
408 tty->driver_data = gb_tty;
411 tty_port_put(&gb_tty->port);
415 static int gb_tty_open(struct tty_struct *tty, struct file *file)
417 struct gb_tty *gb_tty = tty->driver_data;
419 return tty_port_open(&gb_tty->port, tty, file);
422 static void gb_tty_close(struct tty_struct *tty, struct file *file)
424 struct gb_tty *gb_tty = tty->driver_data;
426 tty_port_close(&gb_tty->port, tty, file);
429 static void gb_tty_cleanup(struct tty_struct *tty)
431 struct gb_tty *gb_tty = tty->driver_data;
433 tty_port_put(&gb_tty->port);
436 static void gb_tty_hangup(struct tty_struct *tty)
438 struct gb_tty *gb_tty = tty->driver_data;
440 tty_port_hangup(&gb_tty->port);
443 static int gb_tty_write(struct tty_struct *tty, const unsigned char *buf,
446 struct gb_tty *gb_tty = tty->driver_data;
448 count = kfifo_in_spinlocked(&gb_tty->write_fifo, buf, count,
449 &gb_tty->write_lock);
450 if (count && !gb_tty->close_pending)
451 schedule_work(&gb_tty->tx_work);
456 static int gb_tty_write_room(struct tty_struct *tty)
458 struct gb_tty *gb_tty = tty->driver_data;
462 spin_lock_irqsave(&gb_tty->write_lock, flags);
463 room = kfifo_avail(&gb_tty->write_fifo);
464 spin_unlock_irqrestore(&gb_tty->write_lock, flags);
466 room -= GB_UART_WRITE_ROOM_MARGIN;
473 static int gb_tty_chars_in_buffer(struct tty_struct *tty)
475 struct gb_tty *gb_tty = tty->driver_data;
479 spin_lock_irqsave(&gb_tty->write_lock, flags);
480 chars = kfifo_len(&gb_tty->write_fifo);
481 if (gb_tty->credits < GB_UART_FIRMWARE_CREDITS)
482 chars += GB_UART_FIRMWARE_CREDITS - gb_tty->credits;
483 spin_unlock_irqrestore(&gb_tty->write_lock, flags);
488 static int gb_tty_break_ctl(struct tty_struct *tty, int state)
490 struct gb_tty *gb_tty = tty->driver_data;
492 return send_break(gb_tty, state ? 1 : 0);
495 static void gb_tty_set_termios(struct tty_struct *tty,
496 struct ktermios *termios_old)
498 struct gb_tty *gb_tty = tty->driver_data;
499 struct ktermios *termios = &tty->termios;
500 struct gb_tty_line_coding newline;
501 u8 newctrl = gb_tty->ctrlout;
503 newline.rate = cpu_to_le32(tty_get_baud_rate(tty));
504 newline.format = termios->c_cflag & CSTOPB ?
505 GB_SERIAL_2_STOP_BITS : GB_SERIAL_1_STOP_BITS;
506 newline.parity = termios->c_cflag & PARENB ?
507 (termios->c_cflag & PARODD ? 1 : 2) +
508 (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
510 switch (termios->c_cflag & CSIZE) {
512 newline.data_bits = 5;
515 newline.data_bits = 6;
518 newline.data_bits = 7;
522 newline.data_bits = 8;
526 /* FIXME: needs to clear unsupported bits in the termios */
527 gb_tty->clocal = ((termios->c_cflag & CLOCAL) != 0);
529 if (C_BAUD(tty) == B0) {
530 newline.rate = gb_tty->line_coding.rate;
531 newctrl &= ~(GB_UART_CTRL_DTR | GB_UART_CTRL_RTS);
532 } else if (termios_old && (termios_old->c_cflag & CBAUD) == B0) {
533 newctrl |= (GB_UART_CTRL_DTR | GB_UART_CTRL_RTS);
536 if (newctrl != gb_tty->ctrlout) {
537 gb_tty->ctrlout = newctrl;
538 send_control(gb_tty, newctrl);
541 if (C_CRTSCTS(tty) && C_BAUD(tty) != B0)
542 newline.flow_control |= GB_SERIAL_AUTO_RTSCTS_EN;
544 newline.flow_control &= ~GB_SERIAL_AUTO_RTSCTS_EN;
546 if (memcmp(&gb_tty->line_coding, &newline, sizeof(newline))) {
547 memcpy(&gb_tty->line_coding, &newline, sizeof(newline));
548 send_line_coding(gb_tty);
552 static int gb_tty_tiocmget(struct tty_struct *tty)
554 struct gb_tty *gb_tty = tty->driver_data;
556 return (gb_tty->ctrlout & GB_UART_CTRL_DTR ? TIOCM_DTR : 0) |
557 (gb_tty->ctrlout & GB_UART_CTRL_RTS ? TIOCM_RTS : 0) |
558 (gb_tty->ctrlin & GB_UART_CTRL_DSR ? TIOCM_DSR : 0) |
559 (gb_tty->ctrlin & GB_UART_CTRL_RI ? TIOCM_RI : 0) |
560 (gb_tty->ctrlin & GB_UART_CTRL_DCD ? TIOCM_CD : 0) |
564 static int gb_tty_tiocmset(struct tty_struct *tty, unsigned int set,
567 struct gb_tty *gb_tty = tty->driver_data;
568 u8 newctrl = gb_tty->ctrlout;
570 set = (set & TIOCM_DTR ? GB_UART_CTRL_DTR : 0) |
571 (set & TIOCM_RTS ? GB_UART_CTRL_RTS : 0);
572 clear = (clear & TIOCM_DTR ? GB_UART_CTRL_DTR : 0) |
573 (clear & TIOCM_RTS ? GB_UART_CTRL_RTS : 0);
575 newctrl = (newctrl & ~clear) | set;
576 if (gb_tty->ctrlout == newctrl)
579 gb_tty->ctrlout = newctrl;
580 return send_control(gb_tty, newctrl);
583 static void gb_tty_throttle(struct tty_struct *tty)
585 struct gb_tty *gb_tty = tty->driver_data;
586 unsigned char stop_char;
590 stop_char = STOP_CHAR(tty);
591 retval = gb_tty_write(tty, &stop_char, 1);
596 if (tty->termios.c_cflag & CRTSCTS) {
597 gb_tty->ctrlout &= ~GB_UART_CTRL_RTS;
598 retval = send_control(gb_tty, gb_tty->ctrlout);
602 static void gb_tty_unthrottle(struct tty_struct *tty)
604 struct gb_tty *gb_tty = tty->driver_data;
605 unsigned char start_char;
609 start_char = START_CHAR(tty);
610 retval = gb_tty_write(tty, &start_char, 1);
615 if (tty->termios.c_cflag & CRTSCTS) {
616 gb_tty->ctrlout |= GB_UART_CTRL_RTS;
617 retval = send_control(gb_tty, gb_tty->ctrlout);
621 static int get_serial_info(struct gb_tty *gb_tty,
622 struct serial_struct __user *info)
624 struct serial_struct tmp;
629 memset(&tmp, 0, sizeof(tmp));
630 tmp.flags = ASYNC_LOW_LATENCY | ASYNC_SKIP_TEST;
631 tmp.type = PORT_16550A;
632 tmp.line = gb_tty->minor;
633 tmp.xmit_fifo_size = 16;
634 tmp.baud_base = 9600;
635 tmp.close_delay = gb_tty->port.close_delay / 10;
636 tmp.closing_wait = gb_tty->port.closing_wait == ASYNC_CLOSING_WAIT_NONE ?
637 ASYNC_CLOSING_WAIT_NONE : gb_tty->port.closing_wait / 10;
639 if (copy_to_user(info, &tmp, sizeof(tmp)))
644 static int set_serial_info(struct gb_tty *gb_tty,
645 struct serial_struct __user *newinfo)
647 struct serial_struct new_serial;
648 unsigned int closing_wait;
649 unsigned int close_delay;
652 if (copy_from_user(&new_serial, newinfo, sizeof(new_serial)))
655 close_delay = new_serial.close_delay * 10;
656 closing_wait = new_serial.closing_wait == ASYNC_CLOSING_WAIT_NONE ?
657 ASYNC_CLOSING_WAIT_NONE : new_serial.closing_wait * 10;
659 mutex_lock(&gb_tty->port.mutex);
660 if (!capable(CAP_SYS_ADMIN)) {
661 if ((close_delay != gb_tty->port.close_delay) ||
662 (closing_wait != gb_tty->port.closing_wait))
665 retval = -EOPNOTSUPP;
667 gb_tty->port.close_delay = close_delay;
668 gb_tty->port.closing_wait = closing_wait;
670 mutex_unlock(&gb_tty->port.mutex);
674 static int wait_serial_change(struct gb_tty *gb_tty, unsigned long arg)
677 DECLARE_WAITQUEUE(wait, current);
678 struct async_icount old;
679 struct async_icount new;
681 if (!(arg & (TIOCM_DSR | TIOCM_RI | TIOCM_CD)))
685 spin_lock_irq(&gb_tty->read_lock);
686 old = gb_tty->oldcount;
687 new = gb_tty->iocount;
688 gb_tty->oldcount = new;
689 spin_unlock_irq(&gb_tty->read_lock);
691 if ((arg & TIOCM_DSR) && (old.dsr != new.dsr))
693 if ((arg & TIOCM_CD) && (old.dcd != new.dcd))
695 if ((arg & TIOCM_RI) && (old.rng != new.rng))
698 add_wait_queue(&gb_tty->wioctl, &wait);
699 set_current_state(TASK_INTERRUPTIBLE);
701 remove_wait_queue(&gb_tty->wioctl, &wait);
702 if (gb_tty->disconnected) {
706 } else if (signal_pending(current)) {
707 retval = -ERESTARTSYS;
714 static int get_serial_usage(struct gb_tty *gb_tty,
715 struct serial_icounter_struct __user *count)
717 struct serial_icounter_struct icount;
720 memset(&icount, 0, sizeof(icount));
721 icount.dsr = gb_tty->iocount.dsr;
722 icount.rng = gb_tty->iocount.rng;
723 icount.dcd = gb_tty->iocount.dcd;
724 icount.frame = gb_tty->iocount.frame;
725 icount.overrun = gb_tty->iocount.overrun;
726 icount.parity = gb_tty->iocount.parity;
727 icount.brk = gb_tty->iocount.brk;
729 if (copy_to_user(count, &icount, sizeof(icount)) > 0)
735 static int gb_tty_ioctl(struct tty_struct *tty, unsigned int cmd,
738 struct gb_tty *gb_tty = tty->driver_data;
742 return get_serial_info(gb_tty,
743 (struct serial_struct __user *)arg);
745 return set_serial_info(gb_tty,
746 (struct serial_struct __user *)arg);
748 return wait_serial_change(gb_tty, arg);
750 return get_serial_usage(gb_tty,
751 (struct serial_icounter_struct __user *)arg);
757 static void gb_tty_dtr_rts(struct tty_port *port, int on)
759 struct gb_tty *gb_tty;
762 gb_tty = container_of(port, struct gb_tty, port);
763 newctrl = gb_tty->ctrlout;
766 newctrl |= (GB_UART_CTRL_DTR | GB_UART_CTRL_RTS);
768 newctrl &= ~(GB_UART_CTRL_DTR | GB_UART_CTRL_RTS);
770 gb_tty->ctrlout = newctrl;
771 send_control(gb_tty, newctrl);
774 static int gb_tty_port_activate(struct tty_port *port,
775 struct tty_struct *tty)
777 struct gb_tty *gb_tty;
779 gb_tty = container_of(port, struct gb_tty, port);
781 return gbphy_runtime_get_sync(gb_tty->gbphy_dev);
784 static void gb_tty_port_shutdown(struct tty_port *port)
786 struct gb_tty *gb_tty;
790 gb_tty = container_of(port, struct gb_tty, port);
792 gb_tty->close_pending = true;
794 cancel_work_sync(&gb_tty->tx_work);
796 spin_lock_irqsave(&gb_tty->write_lock, flags);
797 kfifo_reset_out(&gb_tty->write_fifo);
798 spin_unlock_irqrestore(&gb_tty->write_lock, flags);
800 if (gb_tty->credits == GB_UART_FIRMWARE_CREDITS)
803 ret = gb_uart_flush(gb_tty, GB_SERIAL_FLAG_FLUSH_TRANSMITTER);
805 dev_err(&gb_tty->gbphy_dev->dev,
806 "error flushing transmitter: %d\n", ret);
809 gb_uart_wait_for_all_credits(gb_tty);
812 gb_tty->close_pending = false;
814 gbphy_runtime_put_autosuspend(gb_tty->gbphy_dev);
817 static const struct tty_operations gb_ops = {
818 .install = gb_tty_install,
820 .close = gb_tty_close,
821 .cleanup = gb_tty_cleanup,
822 .hangup = gb_tty_hangup,
823 .write = gb_tty_write,
824 .write_room = gb_tty_write_room,
825 .ioctl = gb_tty_ioctl,
826 .throttle = gb_tty_throttle,
827 .unthrottle = gb_tty_unthrottle,
828 .chars_in_buffer = gb_tty_chars_in_buffer,
829 .break_ctl = gb_tty_break_ctl,
830 .set_termios = gb_tty_set_termios,
831 .tiocmget = gb_tty_tiocmget,
832 .tiocmset = gb_tty_tiocmset,
835 static struct tty_port_operations gb_port_ops = {
836 .dtr_rts = gb_tty_dtr_rts,
837 .activate = gb_tty_port_activate,
838 .shutdown = gb_tty_port_shutdown,
841 static int gb_uart_probe(struct gbphy_device *gbphy_dev,
842 const struct gbphy_device_id *id)
844 struct gb_connection *connection;
846 struct gb_tty *gb_tty;
847 struct device *tty_dev;
851 gb_tty = kzalloc(sizeof(*gb_tty), GFP_KERNEL);
855 connection = gb_connection_create(gbphy_dev->bundle,
856 le16_to_cpu(gbphy_dev->cport_desc->id),
857 gb_uart_request_handler);
858 if (IS_ERR(connection)) {
859 retval = PTR_ERR(connection);
863 max_payload = gb_operation_get_payload_size_max(connection);
864 if (max_payload < sizeof(struct gb_uart_send_data_request)) {
866 goto exit_connection_destroy;
869 gb_tty->buffer_payload_max = max_payload -
870 sizeof(struct gb_uart_send_data_request);
872 gb_tty->buffer = kzalloc(gb_tty->buffer_payload_max, GFP_KERNEL);
873 if (!gb_tty->buffer) {
875 goto exit_connection_destroy;
878 INIT_WORK(&gb_tty->tx_work, gb_uart_tx_write_work);
880 retval = kfifo_alloc(&gb_tty->write_fifo, GB_UART_WRITE_FIFO_SIZE,
885 gb_tty->credits = GB_UART_FIRMWARE_CREDITS;
886 init_completion(&gb_tty->credits_complete);
888 minor = alloc_minor(gb_tty);
890 if (minor == -ENOSPC) {
891 dev_err(&connection->bundle->dev,
892 "no more free minor numbers\n");
897 goto exit_kfifo_free;
900 gb_tty->minor = minor;
901 spin_lock_init(&gb_tty->write_lock);
902 spin_lock_init(&gb_tty->read_lock);
903 init_waitqueue_head(&gb_tty->wioctl);
904 mutex_init(&gb_tty->mutex);
906 tty_port_init(&gb_tty->port);
907 gb_tty->port.ops = &gb_port_ops;
909 gb_tty->connection = connection;
910 gb_tty->gbphy_dev = gbphy_dev;
911 gb_connection_set_data(connection, gb_tty);
912 gb_gbphy_set_data(gbphy_dev, gb_tty);
914 retval = gb_connection_enable_tx(connection);
916 goto exit_release_minor;
918 send_control(gb_tty, gb_tty->ctrlout);
920 /* initialize the uart to be 9600n81 */
921 gb_tty->line_coding.rate = cpu_to_le32(9600);
922 gb_tty->line_coding.format = GB_SERIAL_1_STOP_BITS;
923 gb_tty->line_coding.parity = GB_SERIAL_NO_PARITY;
924 gb_tty->line_coding.data_bits = 8;
925 send_line_coding(gb_tty);
927 retval = gb_connection_enable(connection);
929 goto exit_connection_disable;
931 tty_dev = tty_port_register_device(&gb_tty->port, gb_tty_driver, minor,
933 if (IS_ERR(tty_dev)) {
934 retval = PTR_ERR(tty_dev);
935 goto exit_connection_disable;
938 gbphy_runtime_put_autosuspend(gbphy_dev);
941 exit_connection_disable:
942 gb_connection_disable(connection);
944 release_minor(gb_tty);
946 kfifo_free(&gb_tty->write_fifo);
948 kfree(gb_tty->buffer);
949 exit_connection_destroy:
950 gb_connection_destroy(connection);
957 static void gb_uart_remove(struct gbphy_device *gbphy_dev)
959 struct gb_tty *gb_tty = gb_gbphy_get_data(gbphy_dev);
960 struct gb_connection *connection = gb_tty->connection;
961 struct tty_struct *tty;
964 ret = gbphy_runtime_get_sync(gbphy_dev);
966 gbphy_runtime_get_noresume(gbphy_dev);
968 mutex_lock(&gb_tty->mutex);
969 gb_tty->disconnected = true;
971 wake_up_all(&gb_tty->wioctl);
972 mutex_unlock(&gb_tty->mutex);
974 tty = tty_port_tty_get(&gb_tty->port);
980 gb_connection_disable_rx(connection);
981 tty_unregister_device(gb_tty_driver, gb_tty->minor);
983 /* FIXME - free transmit / receive buffers */
985 gb_connection_disable(connection);
986 tty_port_destroy(&gb_tty->port);
987 gb_connection_destroy(connection);
988 release_minor(gb_tty);
989 kfifo_free(&gb_tty->write_fifo);
990 kfree(gb_tty->buffer);
994 static int gb_tty_init(void)
998 gb_tty_driver = tty_alloc_driver(GB_NUM_MINORS, 0);
999 if (IS_ERR(gb_tty_driver)) {
1000 pr_err("Can not allocate tty driver\n");
1002 goto fail_unregister_dev;
1005 gb_tty_driver->driver_name = "gb";
1006 gb_tty_driver->name = GB_NAME;
1007 gb_tty_driver->major = 0;
1008 gb_tty_driver->minor_start = 0;
1009 gb_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1010 gb_tty_driver->subtype = SERIAL_TYPE_NORMAL;
1011 gb_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1012 gb_tty_driver->init_termios = tty_std_termios;
1013 gb_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1014 tty_set_operations(gb_tty_driver, &gb_ops);
1016 retval = tty_register_driver(gb_tty_driver);
1018 pr_err("Can not register tty driver: %d\n", retval);
1019 goto fail_put_gb_tty;
1025 put_tty_driver(gb_tty_driver);
1026 fail_unregister_dev:
1030 static void gb_tty_exit(void)
1032 tty_unregister_driver(gb_tty_driver);
1033 put_tty_driver(gb_tty_driver);
1034 idr_destroy(&tty_minors);
1037 static const struct gbphy_device_id gb_uart_id_table[] = {
1038 { GBPHY_PROTOCOL(GREYBUS_PROTOCOL_UART) },
1041 MODULE_DEVICE_TABLE(gbphy, gb_uart_id_table);
1043 static struct gbphy_driver uart_driver = {
1045 .probe = gb_uart_probe,
1046 .remove = gb_uart_remove,
1047 .id_table = gb_uart_id_table,
1050 static int gb_uart_driver_init(void)
1054 ret = gb_tty_init();
1058 ret = gb_gbphy_register(&uart_driver);
1066 module_init(gb_uart_driver_init);
1068 static void gb_uart_driver_exit(void)
1070 gb_gbphy_deregister(&uart_driver);
1074 module_exit(gb_uart_driver_exit);
1075 MODULE_LICENSE("GPL v2");