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