drivers/staging/greybus/uart.c

   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");