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 = jiffies_to_msecs(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 :
 621                 jiffies_to_msecs(gb_tty->port.closing_wait) / 10;
 622
 623         return 0;
 624 }
 625
 626 static int set_serial_info(struct tty_struct *tty,
 627                            struct serial_struct *ss)
 628 {
 629         struct gb_tty *gb_tty = tty->driver_data;
 630         unsigned int closing_wait;
 631         unsigned int close_delay;
 632         int retval = 0;
 633
 634         close_delay = msecs_to_jiffies(ss->close_delay * 10);
 635         closing_wait = ss->closing_wait == ASYNC_CLOSING_WAIT_NONE ?
 636                         ASYNC_CLOSING_WAIT_NONE :
 637                         msecs_to_jiffies(ss->closing_wait * 10);
 638
 639         mutex_lock(&gb_tty->port.mutex);
 640         if (!capable(CAP_SYS_ADMIN)) {
 641                 if ((close_delay != gb_tty->port.close_delay) ||
 642                     (closing_wait != gb_tty->port.closing_wait))
 643                         retval = -EPERM;
 644         } else {
 645                 gb_tty->port.close_delay = close_delay;
 646                 gb_tty->port.closing_wait = closing_wait;
 647         }
 648         mutex_unlock(&gb_tty->port.mutex);
 649         return retval;
 650 }
 651
 652 static int wait_serial_change(struct gb_tty *gb_tty, unsigned long arg)
 653 {
 654         int retval = 0;
 655         DECLARE_WAITQUEUE(wait, current);
 656         struct async_icount old;
 657         struct async_icount new;
 658
 659         if (!(arg & (TIOCM_DSR | TIOCM_RI | TIOCM_CD)))
 660                 return -EINVAL;
 661
 662         do {
 663                 spin_lock_irq(&gb_tty->read_lock);
 664                 old = gb_tty->oldcount;
 665                 new = gb_tty->iocount;
 666                 gb_tty->oldcount = new;
 667                 spin_unlock_irq(&gb_tty->read_lock);
 668
 669                 if ((arg & TIOCM_DSR) && (old.dsr != new.dsr))
 670                         break;
 671                 if ((arg & TIOCM_CD) && (old.dcd != new.dcd))
 672                         break;
 673                 if ((arg & TIOCM_RI) && (old.rng != new.rng))
 674                         break;
 675
 676                 add_wait_queue(&gb_tty->wioctl, &wait);
 677                 set_current_state(TASK_INTERRUPTIBLE);
 678                 schedule();
 679                 remove_wait_queue(&gb_tty->wioctl, &wait);
 680                 if (gb_tty->disconnected) {
 681                         if (arg & TIOCM_CD)
 682                                 break;
 683                         retval = -ENODEV;
 684                 } else if (signal_pending(current)) {
 685                         retval = -ERESTARTSYS;
 686                 }
 687         } while (!retval);
 688
 689         return retval;
 690 }
 691
 692 static int gb_tty_get_icount(struct tty_struct *tty,
 693                              struct serial_icounter_struct *icount)
 694 {
 695         struct gb_tty *gb_tty = tty->driver_data;
 696
 697         icount->dsr = gb_tty->iocount.dsr;
 698         icount->rng = gb_tty->iocount.rng;
 699         icount->dcd = gb_tty->iocount.dcd;
 700         icount->frame = gb_tty->iocount.frame;
 701         icount->overrun = gb_tty->iocount.overrun;
 702         icount->parity = gb_tty->iocount.parity;
 703         icount->brk = gb_tty->iocount.brk;
 704
 705         return 0;
 706 }
 707
 708 static int gb_tty_ioctl(struct tty_struct *tty, unsigned int cmd,
 709                         unsigned long arg)
 710 {
 711         struct gb_tty *gb_tty = tty->driver_data;
 712
 713         switch (cmd) {
 714         case TIOCMIWAIT:
 715                 return wait_serial_change(gb_tty, arg);
 716         }
 717
 718         return -ENOIOCTLCMD;
 719 }
 720
 721 static void gb_tty_dtr_rts(struct tty_port *port, int on)
 722 {
 723         struct gb_tty *gb_tty;
 724         u8 newctrl;
 725
 726         gb_tty = container_of(port, struct gb_tty, port);
 727         newctrl = gb_tty->ctrlout;
 728
 729         if (on)
 730                 newctrl |= (GB_UART_CTRL_DTR | GB_UART_CTRL_RTS);
 731         else
 732                 newctrl &= ~(GB_UART_CTRL_DTR | GB_UART_CTRL_RTS);
 733
 734         gb_tty->ctrlout = newctrl;
 735         send_control(gb_tty, newctrl);
 736 }
 737
 738 static int gb_tty_port_activate(struct tty_port *port,
 739                                 struct tty_struct *tty)
 740 {
 741         struct gb_tty *gb_tty;
 742
 743         gb_tty = container_of(port, struct gb_tty, port);
 744
 745         return gbphy_runtime_get_sync(gb_tty->gbphy_dev);
 746 }
 747
 748 static void gb_tty_port_shutdown(struct tty_port *port)
 749 {
 750         struct gb_tty *gb_tty;
 751         unsigned long flags;
 752         int ret;
 753
 754         gb_tty = container_of(port, struct gb_tty, port);
 755
 756         gb_tty->close_pending = true;
 757
 758         cancel_work_sync(&gb_tty->tx_work);
 759
 760         spin_lock_irqsave(&gb_tty->write_lock, flags);
 761         kfifo_reset_out(&gb_tty->write_fifo);
 762         spin_unlock_irqrestore(&gb_tty->write_lock, flags);
 763
 764         if (gb_tty->credits == GB_UART_FIRMWARE_CREDITS)
 765                 goto out;
 766
 767         ret = gb_uart_flush(gb_tty, GB_SERIAL_FLAG_FLUSH_TRANSMITTER);
 768         if (ret) {
 769                 dev_err(&gb_tty->gbphy_dev->dev,
 770                         "error flushing transmitter: %d\n", ret);
 771         }
 772
 773         gb_uart_wait_for_all_credits(gb_tty);
 774
 775 out:
 776         gb_tty->close_pending = false;
 777
 778         gbphy_runtime_put_autosuspend(gb_tty->gbphy_dev);
 779 }
 780
 781 static void gb_tty_port_destruct(struct tty_port *port)
 782 {
 783         struct gb_tty *gb_tty = container_of(port, struct gb_tty, port);
 784
 785         if (gb_tty->minor != GB_NUM_MINORS)
 786                 release_minor(gb_tty);
 787         kfifo_free(&gb_tty->write_fifo);
 788         kfree(gb_tty->buffer);
 789         kfree(gb_tty);
 790 }
 791
 792 static const struct tty_operations gb_ops = {
 793         .install =              gb_tty_install,
 794         .open =                 gb_tty_open,
 795         .close =                gb_tty_close,
 796         .cleanup =              gb_tty_cleanup,
 797         .hangup =               gb_tty_hangup,
 798         .write =                gb_tty_write,
 799         .write_room =           gb_tty_write_room,
 800         .ioctl =                gb_tty_ioctl,
 801         .throttle =             gb_tty_throttle,
 802         .unthrottle =           gb_tty_unthrottle,
 803         .chars_in_buffer =      gb_tty_chars_in_buffer,
 804         .break_ctl =            gb_tty_break_ctl,
 805         .set_termios =          gb_tty_set_termios,
 806         .tiocmget =             gb_tty_tiocmget,
 807         .tiocmset =             gb_tty_tiocmset,
 808         .get_icount =           gb_tty_get_icount,
 809         .set_serial =           set_serial_info,
 810         .get_serial =           get_serial_info,
 811 };
 812
 813 static const struct tty_port_operations gb_port_ops = {
 814         .dtr_rts =              gb_tty_dtr_rts,
 815         .activate =             gb_tty_port_activate,
 816         .shutdown =             gb_tty_port_shutdown,
 817         .destruct =             gb_tty_port_destruct,
 818 };
 819
 820 static int gb_uart_probe(struct gbphy_device *gbphy_dev,
 821                          const struct gbphy_device_id *id)
 822 {
 823         struct gb_connection *connection;
 824         size_t max_payload;
 825         struct gb_tty *gb_tty;
 826         struct device *tty_dev;
 827         int retval;
 828         int minor;
 829
 830         connection = gb_connection_create(gbphy_dev->bundle,
 831                                           le16_to_cpu(gbphy_dev->cport_desc->id),
 832                                           gb_uart_request_handler);
 833         if (IS_ERR(connection))
 834                 return PTR_ERR(connection);
 835
 836         max_payload = gb_operation_get_payload_size_max(connection);
 837         if (max_payload < sizeof(struct gb_uart_send_data_request)) {
 838                 retval = -EINVAL;
 839                 goto exit_connection_destroy;
 840         }
 841
 842         gb_tty = kzalloc(sizeof(*gb_tty), GFP_KERNEL);
 843         if (!gb_tty) {
 844                 retval = -ENOMEM;
 845                 goto exit_connection_destroy;
 846         }
 847
 848         tty_port_init(&gb_tty->port);
 849         gb_tty->port.ops = &gb_port_ops;
 850         gb_tty->minor = GB_NUM_MINORS;
 851
 852         gb_tty->buffer_payload_max = max_payload -
 853                         sizeof(struct gb_uart_send_data_request);
 854
 855         gb_tty->buffer = kzalloc(gb_tty->buffer_payload_max, GFP_KERNEL);
 856         if (!gb_tty->buffer) {
 857                 retval = -ENOMEM;
 858                 goto exit_put_port;
 859         }
 860
 861         INIT_WORK(&gb_tty->tx_work, gb_uart_tx_write_work);
 862
 863         retval = kfifo_alloc(&gb_tty->write_fifo, GB_UART_WRITE_FIFO_SIZE,
 864                              GFP_KERNEL);
 865         if (retval)
 866                 goto exit_put_port;
 867
 868         gb_tty->credits = GB_UART_FIRMWARE_CREDITS;
 869         init_completion(&gb_tty->credits_complete);
 870
 871         minor = alloc_minor(gb_tty);
 872         if (minor < 0) {
 873                 if (minor == -ENOSPC) {
 874                         dev_err(&gbphy_dev->dev,
 875                                 "no more free minor numbers\n");
 876                         retval = -ENODEV;
 877                 } else {
 878                         retval = minor;
 879                 }
 880                 goto exit_put_port;
 881         }
 882
 883         gb_tty->minor = minor;
 884         spin_lock_init(&gb_tty->write_lock);
 885         spin_lock_init(&gb_tty->read_lock);
 886         init_waitqueue_head(&gb_tty->wioctl);
 887         mutex_init(&gb_tty->mutex);
 888
 889         gb_tty->connection = connection;
 890         gb_tty->gbphy_dev = gbphy_dev;
 891         gb_connection_set_data(connection, gb_tty);
 892         gb_gbphy_set_data(gbphy_dev, gb_tty);
 893
 894         retval = gb_connection_enable_tx(connection);
 895         if (retval)
 896                 goto exit_put_port;
 897
 898         send_control(gb_tty, gb_tty->ctrlout);
 899
 900         /* initialize the uart to be 9600n81 */
 901         gb_tty->line_coding.rate = cpu_to_le32(9600);
 902         gb_tty->line_coding.format = GB_SERIAL_1_STOP_BITS;
 903         gb_tty->line_coding.parity = GB_SERIAL_NO_PARITY;
 904         gb_tty->line_coding.data_bits = 8;
 905         send_line_coding(gb_tty);
 906
 907         retval = gb_connection_enable(connection);
 908         if (retval)
 909                 goto exit_connection_disable;
 910
 911         tty_dev = tty_port_register_device(&gb_tty->port, gb_tty_driver, minor,
 912                                            &gbphy_dev->dev);
 913         if (IS_ERR(tty_dev)) {
 914                 retval = PTR_ERR(tty_dev);
 915                 goto exit_connection_disable;
 916         }
 917
 918         gbphy_runtime_put_autosuspend(gbphy_dev);
 919         return 0;
 920
 921 exit_connection_disable:
 922         gb_connection_disable(connection);
 923 exit_put_port:
 924         tty_port_put(&gb_tty->port);
 925 exit_connection_destroy:
 926         gb_connection_destroy(connection);
 927
 928         return retval;
 929 }
 930
 931 static void gb_uart_remove(struct gbphy_device *gbphy_dev)
 932 {
 933         struct gb_tty *gb_tty = gb_gbphy_get_data(gbphy_dev);
 934         struct gb_connection *connection = gb_tty->connection;
 935         struct tty_struct *tty;
 936         int ret;
 937
 938         ret = gbphy_runtime_get_sync(gbphy_dev);
 939         if (ret)
 940                 gbphy_runtime_get_noresume(gbphy_dev);
 941
 942         mutex_lock(&gb_tty->mutex);
 943         gb_tty->disconnected = true;
 944
 945         wake_up_all(&gb_tty->wioctl);
 946         mutex_unlock(&gb_tty->mutex);
 947
 948         tty = tty_port_tty_get(&gb_tty->port);
 949         if (tty) {
 950                 tty_vhangup(tty);
 951                 tty_kref_put(tty);
 952         }
 953
 954         gb_connection_disable_rx(connection);
 955         tty_unregister_device(gb_tty_driver, gb_tty->minor);
 956
 957         gb_connection_disable(connection);
 958         gb_connection_destroy(connection);
 959
 960         tty_port_put(&gb_tty->port);
 961 }
 962
 963 static int gb_tty_init(void)
 964 {
 965         int retval = 0;
 966
 967         gb_tty_driver = tty_alloc_driver(GB_NUM_MINORS, 0);
 968         if (IS_ERR(gb_tty_driver)) {
 969                 pr_err("Can not allocate tty driver\n");
 970                 retval = -ENOMEM;
 971                 goto fail_unregister_dev;
 972         }
 973
 974         gb_tty_driver->driver_name = "gb";
 975         gb_tty_driver->name = GB_NAME;
 976         gb_tty_driver->major = 0;
 977         gb_tty_driver->minor_start = 0;
 978         gb_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
 979         gb_tty_driver->subtype = SERIAL_TYPE_NORMAL;
 980         gb_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
 981         gb_tty_driver->init_termios = tty_std_termios;
 982         gb_tty_driver->init_termios.c_cflag = B9600 | CS8 |
 983                 CREAD | HUPCL | CLOCAL;
 984         tty_set_operations(gb_tty_driver, &gb_ops);
 985
 986         retval = tty_register_driver(gb_tty_driver);
 987         if (retval) {
 988                 pr_err("Can not register tty driver: %d\n", retval);
 989                 goto fail_put_gb_tty;
 990         }
 991
 992         return 0;
 993
 994 fail_put_gb_tty:
 995         put_tty_driver(gb_tty_driver);
 996 fail_unregister_dev:
 997         return retval;
 998 }
 999
1000 static void gb_tty_exit(void)
1001 {
1002         tty_unregister_driver(gb_tty_driver);
1003         put_tty_driver(gb_tty_driver);
1004         idr_destroy(&tty_minors);
1005 }
1006
1007 static const struct gbphy_device_id gb_uart_id_table[] = {
1008         { GBPHY_PROTOCOL(GREYBUS_PROTOCOL_UART) },
1009         { },
1010 };
1011 MODULE_DEVICE_TABLE(gbphy, gb_uart_id_table);
1012
1013 static struct gbphy_driver uart_driver = {
1014         .name           = "uart",
1015         .probe          = gb_uart_probe,
1016         .remove         = gb_uart_remove,
1017         .id_table       = gb_uart_id_table,
1018 };
1019
1020 static int gb_uart_driver_init(void)
1021 {
1022         int ret;
1023
1024         ret = gb_tty_init();
1025         if (ret)
1026                 return ret;
1027
1028         ret = gb_gbphy_register(&uart_driver);
1029         if (ret) {
1030                 gb_tty_exit();
1031                 return ret;
1032         }
1033
1034         return 0;
1035 }
1036 module_init(gb_uart_driver_init);
1037
1038 static void gb_uart_driver_exit(void)
1039 {
1040         gb_gbphy_deregister(&uart_driver);
1041         gb_tty_exit();
1042 }
1043
1044 module_exit(gb_uart_driver_exit);
1045 MODULE_LICENSE("GPL v2");