drivers/usb/host/xhci-dbgtty.c

   1 /**
   2  * xhci-dbgtty.c - tty glue for xHCI debug capability
   3  *
   4  * Copyright (C) 2017 Intel Corporation
   5  *
   6  * Author: Lu Baolu <baolu.lu@linux.intel.com>
   7  */
   8
   9 #include <linux/slab.h>
  10 #include <linux/tty.h>
  11 #include <linux/tty_flip.h>
  12
  13 #include "xhci.h"
  14 #include "xhci-dbgcap.h"
  15
  16 static unsigned int
  17 dbc_send_packet(struct dbc_port *port, char *packet, unsigned int size)
  18 {
  19         unsigned int            len;
  20
  21         len = kfifo_len(&port->write_fifo);
  22         if (len < size)
  23                 size = len;
  24         if (size != 0)
  25                 size = kfifo_out(&port->write_fifo, packet, size);
  26         return size;
  27 }
  28
  29 static int dbc_start_tx(struct dbc_port *port)
  30         __releases(&port->port_lock)
  31         __acquires(&port->port_lock)
  32 {
  33         int                     len;
  34         struct dbc_request      *req;
  35         int                     status = 0;
  36         bool                    do_tty_wake = false;
  37         struct list_head        *pool = &port->write_pool;
  38
  39         while (!list_empty(pool)) {
  40                 req = list_entry(pool->next, struct dbc_request, list_pool);
  41                 len = dbc_send_packet(port, req->buf, DBC_MAX_PACKET);
  42                 if (len == 0)
  43                         break;
  44                 do_tty_wake = true;
  45
  46                 req->length = len;
  47                 list_del(&req->list_pool);
  48
  49                 spin_unlock(&port->port_lock);
  50                 status = dbc_ep_queue(port->out, req, GFP_ATOMIC);
  51                 spin_lock(&port->port_lock);
  52
  53                 if (status) {
  54                         list_add(&req->list_pool, pool);
  55                         break;
  56                 }
  57         }
  58
  59         if (do_tty_wake && port->port.tty)
  60                 tty_wakeup(port->port.tty);
  61
  62         return status;
  63 }
  64
  65 static void dbc_start_rx(struct dbc_port *port)
  66         __releases(&port->port_lock)
  67         __acquires(&port->port_lock)
  68 {
  69         struct dbc_request      *req;
  70         int                     status;
  71         struct list_head        *pool = &port->read_pool;
  72
  73         while (!list_empty(pool)) {
  74                 if (!port->port.tty)
  75                         break;
  76
  77                 req = list_entry(pool->next, struct dbc_request, list_pool);
  78                 list_del(&req->list_pool);
  79                 req->length = DBC_MAX_PACKET;
  80
  81                 spin_unlock(&port->port_lock);
  82                 status = dbc_ep_queue(port->in, req, GFP_ATOMIC);
  83                 spin_lock(&port->port_lock);
  84
  85                 if (status) {
  86                         list_add(&req->list_pool, pool);
  87                         break;
  88                 }
  89         }
  90 }
  91
  92 static void
  93 dbc_read_complete(struct xhci_hcd *xhci, struct dbc_request *req)
  94 {
  95         unsigned long           flags;
  96         struct xhci_dbc         *dbc = xhci->dbc;
  97         struct dbc_port         *port = &dbc->port;
  98
  99         spin_lock_irqsave(&port->port_lock, flags);
 100         list_add_tail(&req->list_pool, &port->read_queue);
 101         tasklet_schedule(&port->push);
 102         spin_unlock_irqrestore(&port->port_lock, flags);
 103 }
 104
 105 static void dbc_write_complete(struct xhci_hcd *xhci, struct dbc_request *req)
 106 {
 107         unsigned long           flags;
 108         struct xhci_dbc         *dbc = xhci->dbc;
 109         struct dbc_port         *port = &dbc->port;
 110
 111         spin_lock_irqsave(&port->port_lock, flags);
 112         list_add(&req->list_pool, &port->write_pool);
 113         switch (req->status) {
 114         case 0:
 115                 dbc_start_tx(port);
 116                 break;
 117         case -ESHUTDOWN:
 118                 break;
 119         default:
 120                 xhci_warn(xhci, "unexpected write complete status %d\n",
 121                           req->status);
 122                 break;
 123         }
 124         spin_unlock_irqrestore(&port->port_lock, flags);
 125 }
 126
 127 static void xhci_dbc_free_req(struct dbc_ep *dep, struct dbc_request *req)
 128 {
 129         kfree(req->buf);
 130         dbc_free_request(dep, req);
 131 }
 132
 133 static int
 134 xhci_dbc_alloc_requests(struct dbc_ep *dep, struct list_head *head,
 135                         void (*fn)(struct xhci_hcd *, struct dbc_request *))
 136 {
 137         int                     i;
 138         struct dbc_request      *req;
 139
 140         for (i = 0; i < DBC_QUEUE_SIZE; i++) {
 141                 req = dbc_alloc_request(dep, GFP_ATOMIC);
 142                 if (!req)
 143                         break;
 144
 145                 req->length = DBC_MAX_PACKET;
 146                 req->buf = kmalloc(req->length, GFP_KERNEL);
 147                 if (!req->buf) {
 148                         xhci_dbc_free_req(dep, req);
 149                         break;
 150                 }
 151
 152                 req->complete = fn;
 153                 list_add_tail(&req->list_pool, head);
 154         }
 155
 156         return list_empty(head) ? -ENOMEM : 0;
 157 }
 158
 159 static void
 160 xhci_dbc_free_requests(struct dbc_ep *dep, struct list_head *head)
 161 {
 162         struct dbc_request      *req;
 163
 164         while (!list_empty(head)) {
 165                 req = list_entry(head->next, struct dbc_request, list_pool);
 166                 list_del(&req->list_pool);
 167                 xhci_dbc_free_req(dep, req);
 168         }
 169 }
 170
 171 static int dbc_tty_install(struct tty_driver *driver, struct tty_struct *tty)
 172 {
 173         struct dbc_port         *port = driver->driver_state;
 174
 175         tty->driver_data = port;
 176
 177         return tty_port_install(&port->port, driver, tty);
 178 }
 179
 180 static int dbc_tty_open(struct tty_struct *tty, struct file *file)
 181 {
 182         struct dbc_port         *port = tty->driver_data;
 183
 184         return tty_port_open(&port->port, tty, file);
 185 }
 186
 187 static void dbc_tty_close(struct tty_struct *tty, struct file *file)
 188 {
 189         struct dbc_port         *port = tty->driver_data;
 190
 191         tty_port_close(&port->port, tty, file);
 192 }
 193
 194 static int dbc_tty_write(struct tty_struct *tty,
 195                          const unsigned char *buf,
 196                          int count)
 197 {
 198         struct dbc_port         *port = tty->driver_data;
 199         unsigned long           flags;
 200
 201         spin_lock_irqsave(&port->port_lock, flags);
 202         if (count)
 203                 count = kfifo_in(&port->write_fifo, buf, count);
 204         dbc_start_tx(port);
 205         spin_unlock_irqrestore(&port->port_lock, flags);
 206
 207         return count;
 208 }
 209
 210 static int dbc_tty_put_char(struct tty_struct *tty, unsigned char ch)
 211 {
 212         struct dbc_port         *port = tty->driver_data;
 213         unsigned long           flags;
 214         int                     status;
 215
 216         spin_lock_irqsave(&port->port_lock, flags);
 217         status = kfifo_put(&port->write_fifo, ch);
 218         spin_unlock_irqrestore(&port->port_lock, flags);
 219
 220         return status;
 221 }
 222
 223 static void dbc_tty_flush_chars(struct tty_struct *tty)
 224 {
 225         struct dbc_port         *port = tty->driver_data;
 226         unsigned long           flags;
 227
 228         spin_lock_irqsave(&port->port_lock, flags);
 229         dbc_start_tx(port);
 230         spin_unlock_irqrestore(&port->port_lock, flags);
 231 }
 232
 233 static int dbc_tty_write_room(struct tty_struct *tty)
 234 {
 235         struct dbc_port         *port = tty->driver_data;
 236         unsigned long           flags;
 237         int                     room = 0;
 238
 239         spin_lock_irqsave(&port->port_lock, flags);
 240         room = kfifo_avail(&port->write_fifo);
 241         spin_unlock_irqrestore(&port->port_lock, flags);
 242
 243         return room;
 244 }
 245
 246 static int dbc_tty_chars_in_buffer(struct tty_struct *tty)
 247 {
 248         struct dbc_port         *port = tty->driver_data;
 249         unsigned long           flags;
 250         int                     chars = 0;
 251
 252         spin_lock_irqsave(&port->port_lock, flags);
 253         chars = kfifo_len(&port->write_fifo);
 254         spin_unlock_irqrestore(&port->port_lock, flags);
 255
 256         return chars;
 257 }
 258
 259 static void dbc_tty_unthrottle(struct tty_struct *tty)
 260 {
 261         struct dbc_port         *port = tty->driver_data;
 262         unsigned long           flags;
 263
 264         spin_lock_irqsave(&port->port_lock, flags);
 265         tasklet_schedule(&port->push);
 266         spin_unlock_irqrestore(&port->port_lock, flags);
 267 }
 268
 269 static const struct tty_operations dbc_tty_ops = {
 270         .install                = dbc_tty_install,
 271         .open                   = dbc_tty_open,
 272         .close                  = dbc_tty_close,
 273         .write                  = dbc_tty_write,
 274         .put_char               = dbc_tty_put_char,
 275         .flush_chars            = dbc_tty_flush_chars,
 276         .write_room             = dbc_tty_write_room,
 277         .chars_in_buffer        = dbc_tty_chars_in_buffer,
 278         .unthrottle             = dbc_tty_unthrottle,
 279 };
 280
 281 static struct tty_driver *dbc_tty_driver;
 282
 283 int xhci_dbc_tty_register_driver(struct xhci_hcd *xhci)
 284 {
 285         int                     status;
 286         struct xhci_dbc         *dbc = xhci->dbc;
 287
 288         dbc_tty_driver = tty_alloc_driver(1, TTY_DRIVER_REAL_RAW |
 289                                           TTY_DRIVER_DYNAMIC_DEV);
 290         if (IS_ERR(dbc_tty_driver)) {
 291                 status = PTR_ERR(dbc_tty_driver);
 292                 dbc_tty_driver = NULL;
 293                 return status;
 294         }
 295
 296         dbc_tty_driver->driver_name = "dbc_serial";
 297         dbc_tty_driver->name = "ttyDBC";
 298
 299         dbc_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
 300         dbc_tty_driver->subtype = SERIAL_TYPE_NORMAL;
 301         dbc_tty_driver->init_termios = tty_std_termios;
 302         dbc_tty_driver->init_termios.c_cflag =
 303                         B9600 | CS8 | CREAD | HUPCL | CLOCAL;
 304         dbc_tty_driver->init_termios.c_ispeed = 9600;
 305         dbc_tty_driver->init_termios.c_ospeed = 9600;
 306         dbc_tty_driver->driver_state = &dbc->port;
 307
 308         tty_set_operations(dbc_tty_driver, &dbc_tty_ops);
 309
 310         status = tty_register_driver(dbc_tty_driver);
 311         if (status) {
 312                 xhci_err(xhci,
 313                          "can't register dbc tty driver, err %d\n", status);
 314                 put_tty_driver(dbc_tty_driver);
 315                 dbc_tty_driver = NULL;
 316         }
 317
 318         return status;
 319 }
 320
 321 void xhci_dbc_tty_unregister_driver(void)
 322 {
 323         if (dbc_tty_driver) {
 324                 tty_unregister_driver(dbc_tty_driver);
 325                 put_tty_driver(dbc_tty_driver);
 326                 dbc_tty_driver = NULL;
 327         }
 328 }
 329
 330 static void dbc_rx_push(unsigned long _port)
 331 {
 332         struct dbc_request      *req;
 333         struct tty_struct       *tty;
 334         unsigned long           flags;
 335         bool                    do_push = false;
 336         bool                    disconnect = false;
 337         struct dbc_port         *port = (void *)_port;
 338         struct list_head        *queue = &port->read_queue;
 339
 340         spin_lock_irqsave(&port->port_lock, flags);
 341         tty = port->port.tty;
 342         while (!list_empty(queue)) {
 343                 req = list_first_entry(queue, struct dbc_request, list_pool);
 344
 345                 if (tty && tty_throttled(tty))
 346                         break;
 347
 348                 switch (req->status) {
 349                 case 0:
 350                         break;
 351                 case -ESHUTDOWN:
 352                         disconnect = true;
 353                         break;
 354                 default:
 355                         pr_warn("ttyDBC0: unexpected RX status %d\n",
 356                                 req->status);
 357                         break;
 358                 }
 359
 360                 if (req->actual) {
 361                         char            *packet = req->buf;
 362                         unsigned int    n, size = req->actual;
 363                         int             count;
 364
 365                         n = port->n_read;
 366                         if (n) {
 367                                 packet += n;
 368                                 size -= n;
 369                         }
 370
 371                         count = tty_insert_flip_string(&port->port, packet,
 372                                                        size);
 373                         if (count)
 374                                 do_push = true;
 375                         if (count != size) {
 376                                 port->n_read += count;
 377                                 break;
 378                         }
 379                         port->n_read = 0;
 380                 }
 381
 382                 list_move(&req->list_pool, &port->read_pool);
 383         }
 384
 385         if (do_push)
 386                 tty_flip_buffer_push(&port->port);
 387
 388         if (!list_empty(queue) && tty) {
 389                 if (!tty_throttled(tty)) {
 390                         if (do_push)
 391                                 tasklet_schedule(&port->push);
 392                         else
 393                                 pr_warn("ttyDBC0: RX not scheduled?\n");
 394                 }
 395         }
 396
 397         if (!disconnect)
 398                 dbc_start_rx(port);
 399
 400         spin_unlock_irqrestore(&port->port_lock, flags);
 401 }
 402
 403 static int dbc_port_activate(struct tty_port *_port, struct tty_struct *tty)
 404 {
 405         unsigned long   flags;
 406         struct dbc_port *port = container_of(_port, struct dbc_port, port);
 407
 408         spin_lock_irqsave(&port->port_lock, flags);
 409         dbc_start_rx(port);
 410         spin_unlock_irqrestore(&port->port_lock, flags);
 411
 412         return 0;
 413 }
 414
 415 static const struct tty_port_operations dbc_port_ops = {
 416         .activate =     dbc_port_activate,
 417 };
 418
 419 static void
 420 xhci_dbc_tty_init_port(struct xhci_hcd *xhci, struct dbc_port *port)
 421 {
 422         tty_port_init(&port->port);
 423         spin_lock_init(&port->port_lock);
 424         tasklet_init(&port->push, dbc_rx_push, (unsigned long)port);
 425         INIT_LIST_HEAD(&port->read_pool);
 426         INIT_LIST_HEAD(&port->read_queue);
 427         INIT_LIST_HEAD(&port->write_pool);
 428
 429         port->in =              get_in_ep(xhci);
 430         port->out =             get_out_ep(xhci);
 431         port->port.ops =        &dbc_port_ops;
 432         port->n_read =          0;
 433 }
 434
 435 static void
 436 xhci_dbc_tty_exit_port(struct dbc_port *port)
 437 {
 438         tasklet_kill(&port->push);
 439         tty_port_destroy(&port->port);
 440 }
 441
 442 int xhci_dbc_tty_register_device(struct xhci_hcd *xhci)
 443 {
 444         int                     ret;
 445         struct device           *tty_dev;
 446         struct xhci_dbc         *dbc = xhci->dbc;
 447         struct dbc_port         *port = &dbc->port;
 448
 449         xhci_dbc_tty_init_port(xhci, port);
 450         tty_dev = tty_port_register_device(&port->port,
 451                                            dbc_tty_driver, 0, NULL);
 452         if (IS_ERR(tty_dev)) {
 453                 ret = PTR_ERR(tty_dev);
 454                 goto register_fail;
 455         }
 456
 457         ret = kfifo_alloc(&port->write_fifo, DBC_WRITE_BUF_SIZE, GFP_KERNEL);
 458         if (ret)
 459                 goto buf_alloc_fail;
 460
 461         ret = xhci_dbc_alloc_requests(port->in, &port->read_pool,
 462                                       dbc_read_complete);
 463         if (ret)
 464                 goto request_fail;
 465
 466         ret = xhci_dbc_alloc_requests(port->out, &port->write_pool,
 467                                       dbc_write_complete);
 468         if (ret)
 469                 goto request_fail;
 470
 471         port->registered = true;
 472
 473         return 0;
 474
 475 request_fail:
 476         xhci_dbc_free_requests(port->in, &port->read_pool);
 477         xhci_dbc_free_requests(port->out, &port->write_pool);
 478         kfifo_free(&port->write_fifo);
 479
 480 buf_alloc_fail:
 481         tty_unregister_device(dbc_tty_driver, 0);
 482
 483 register_fail:
 484         xhci_dbc_tty_exit_port(port);
 485
 486         xhci_err(xhci, "can't register tty port, err %d\n", ret);
 487
 488         return ret;
 489 }
 490
 491 void xhci_dbc_tty_unregister_device(struct xhci_hcd *xhci)
 492 {
 493         struct xhci_dbc         *dbc = xhci->dbc;
 494         struct dbc_port         *port = &dbc->port;
 495
 496         tty_unregister_device(dbc_tty_driver, 0);
 497         xhci_dbc_tty_exit_port(port);
 498         port->registered = false;
 499
 500         kfifo_free(&port->write_fifo);
 501         xhci_dbc_free_requests(get_out_ep(xhci), &port->read_pool);
 502         xhci_dbc_free_requests(get_out_ep(xhci), &port->read_queue);
 503         xhci_dbc_free_requests(get_in_ep(xhci), &port->write_pool);
 504 }