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