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