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