1 /* 2 * UART driver for the Greybus "generic" UART module. 3 * 4 * Copyright 2014 Google Inc. 5 * Copyright 2014 Linaro Ltd. 6 * 7 * Released under the GPLv2 only. 8 * 9 * Heavily based on drivers/usb/class/cdc-acm.c and 10 * drivers/usb/serial/usb-serial.c. 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 /* 16 is more than enough */ 37 #define GB_NAME "ttyGB" 38 39 #define GB_UART_WRITE_FIFO_SIZE PAGE_SIZE 40 #define GB_UART_WRITE_ROOM_MARGIN 1 /* leave some space in fifo */ 41 #define GB_UART_FIRMWARE_CREDITS 4096 42 #define GB_UART_CREDIT_WAIT_TIMEOUT_MSEC 10000 43 44 struct gb_tty_line_coding { 45 __le32 rate; 46 __u8 format; 47 __u8 parity; 48 __u8 data_bits; 49 __u8 flow_control; 50 }; 51 52 struct 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; /* input control lines */ 69 u8 ctrlout; /* output control lines */ 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 78 static struct tty_driver *gb_tty_driver; 79 static DEFINE_IDR(tty_minors); 80 static DEFINE_MUTEX(table_lock); 81 82 static 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 /* overrun is special, not associated with a char */ 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 138 static 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 158 static 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 * the port the tty layer may be waiting for credits 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 208 static 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 234 static 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 290 static 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 300 static 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 310 static 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 325 static 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 343 static 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 352 static 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 372 static 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 384 static void release_minor(struct gb_tty *gb_tty) 385 { 386 int minor = gb_tty->minor; 387 388 gb_tty->minor = 0; /* Maybe should use an invalid value instead */ 389 mutex_lock(&table_lock); 390 idr_remove(&tty_minors, minor); 391 mutex_unlock(&table_lock); 392 } 393 394 static 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; 409 error: 410 tty_port_put(&gb_tty->port); 411 return retval; 412 } 413 414 static 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 421 static 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 428 static 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 435 static 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 442 static 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 455 static 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 472 static 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 487 static 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 494 static 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 /* FIXME: needs to clear unsupported bits in the termios */ 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 551 static 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 563 static 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 582 static 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 601 static 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 620 static 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 640 static 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 670 static 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 710 static 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 726 static 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 745 static 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 762 static 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 772 static 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 799 out: 800 gb_tty->close_pending = false; 801 802 gbphy_runtime_put_autosuspend(gb_tty->gbphy_dev); 803 } 804 805 static 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 824 static 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 830 static 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 /* initialize the uart to be 9600n81 */ 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 930 exit_connection_disable: 931 gb_connection_disable(connection); 932 exit_release_minor: 933 release_minor(gb_tty); 934 exit_kfifo_free: 935 kfifo_free(&gb_tty->write_fifo); 936 exit_buf_free: 937 kfree(gb_tty->buffer); 938 exit_connection_destroy: 939 gb_connection_destroy(connection); 940 exit_tty_free: 941 kfree(gb_tty); 942 943 return retval; 944 } 945 946 static 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 /* FIXME - free transmit / receive buffers */ 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 983 static 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 1014 fail_put_gb_tty: 1015 put_tty_driver(gb_tty_driver); 1016 fail_unregister_dev: 1017 return retval; 1018 } 1019 1020 static 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 1027 static const struct gbphy_device_id gb_uart_id_table[] = { 1028 { GBPHY_PROTOCOL(GREYBUS_PROTOCOL_UART) }, 1029 { }, 1030 }; 1031 MODULE_DEVICE_TABLE(gbphy, gb_uart_id_table); 1032 1033 static 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 1040 static 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 } 1056 module_init(gb_uart_driver_init); 1057 1058 static void gb_uart_driver_exit(void) 1059 { 1060 gb_gbphy_deregister(&uart_driver); 1061 gb_tty_exit(); 1062 } 1063 1064 module_exit(gb_uart_driver_exit); 1065 MODULE_LICENSE("GPL v2"); 1066