drivers/tty/serial/8250/8250_aspeed_vuart.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  *  Serial Port driver for Aspeed VUART device
   4  *
   5  *    Copyright (C) 2016 Jeremy Kerr <jk@ozlabs.org>, IBM Corp.
   6  *    Copyright (C) 2006 Arnd Bergmann <arnd@arndb.de>, IBM Corp.
   7  */
   8 #include <linux/device.h>
   9 #include <linux/module.h>
  10 #include <linux/of_address.h>
  11 #include <linux/of_irq.h>
  12 #include <linux/of_platform.h>
  13 #include <linux/regmap.h>
  14 #include <linux/mfd/syscon.h>
  15 #include <linux/tty.h>
  16 #include <linux/tty_flip.h>
  17 #include <linux/clk.h>
  18
  19 #include "8250.h"
  20
  21 #define ASPEED_VUART_GCRA               0x20
  22 #define ASPEED_VUART_GCRA_VUART_EN              BIT(0)
  23 #define ASPEED_VUART_GCRA_HOST_SIRQ_POLARITY    BIT(1)
  24 #define ASPEED_VUART_GCRA_DISABLE_HOST_TX_DISCARD BIT(5)
  25 #define ASPEED_VUART_GCRB               0x24
  26 #define ASPEED_VUART_GCRB_HOST_SIRQ_MASK        GENMASK(7, 4)
  27 #define ASPEED_VUART_GCRB_HOST_SIRQ_SHIFT       4
  28 #define ASPEED_VUART_ADDRL              0x28
  29 #define ASPEED_VUART_ADDRH              0x2c
  30
  31 #define ASPEED_VUART_DEFAULT_LPC_ADDR   0x3f8
  32 #define ASPEED_VUART_DEFAULT_SIRQ       4
  33 #define ASPEED_VUART_DEFAULT_SIRQ_POLARITY      IRQ_TYPE_LEVEL_LOW
  34
  35 struct aspeed_vuart {
  36         struct device           *dev;
  37         struct clk              *clk;
  38         int                     line;
  39         struct timer_list       unthrottle_timer;
  40         struct uart_8250_port   *port;
  41 };
  42
  43 /*
  44  * If we fill the tty flip buffers, we throttle the data ready interrupt
  45  * to prevent dropped characters. This timeout defines how long we wait
  46  * to (conditionally, depending on buffer state) unthrottle.
  47  */
  48 static const int unthrottle_timeout = HZ/10;
  49
  50 /*
  51  * The VUART is basically two UART 'front ends' connected by their FIFO
  52  * (no actual serial line in between). One is on the BMC side (management
  53  * controller) and one is on the host CPU side.
  54  *
  55  * It allows the BMC to provide to the host a "UART" that pipes into
  56  * the BMC itself and can then be turned by the BMC into a network console
  57  * of some sort for example.
  58  *
  59  * This driver is for the BMC side. The sysfs files allow the BMC
  60  * userspace which owns the system configuration policy, to specify
  61  * at what IO port and interrupt number the host side will appear
  62  * to the host on the Host <-> BMC LPC bus. It could be different on a
  63  * different system (though most of them use 3f8/4).
  64  */
  65
  66 static inline u8 aspeed_vuart_readb(struct aspeed_vuart *vuart, u8 reg)
  67 {
  68         return readb(vuart->port->port.membase + reg);
  69 }
  70
  71 static inline void aspeed_vuart_writeb(struct aspeed_vuart *vuart, u8 val, u8 reg)
  72 {
  73         writeb(val, vuart->port->port.membase + reg);
  74 }
  75
  76 static ssize_t lpc_address_show(struct device *dev,
  77                                 struct device_attribute *attr, char *buf)
  78 {
  79         struct aspeed_vuart *vuart = dev_get_drvdata(dev);
  80         u16 addr;
  81
  82         addr = (aspeed_vuart_readb(vuart, ASPEED_VUART_ADDRH) << 8) |
  83                 (aspeed_vuart_readb(vuart, ASPEED_VUART_ADDRL));
  84
  85         return sysfs_emit(buf, "0x%x\n", addr);
  86 }
  87
  88 static int aspeed_vuart_set_lpc_address(struct aspeed_vuart *vuart, u32 addr)
  89 {
  90         if (addr > U16_MAX)
  91                 return -EINVAL;
  92
  93         aspeed_vuart_writeb(vuart, addr >> 8, ASPEED_VUART_ADDRH);
  94         aspeed_vuart_writeb(vuart, addr >> 0, ASPEED_VUART_ADDRL);
  95
  96         return 0;
  97 }
  98
  99 static ssize_t lpc_address_store(struct device *dev,
 100                                  struct device_attribute *attr,
 101                                  const char *buf, size_t count)
 102 {
 103         struct aspeed_vuart *vuart = dev_get_drvdata(dev);
 104         u32 val;
 105         int err;
 106
 107         err = kstrtou32(buf, 0, &val);
 108         if (err)
 109                 return err;
 110
 111         err = aspeed_vuart_set_lpc_address(vuart, val);
 112         return err ? : count;
 113 }
 114
 115 static DEVICE_ATTR_RW(lpc_address);
 116
 117 static ssize_t sirq_show(struct device *dev,
 118                          struct device_attribute *attr, char *buf)
 119 {
 120         struct aspeed_vuart *vuart = dev_get_drvdata(dev);
 121         u8 reg;
 122
 123         reg = aspeed_vuart_readb(vuart, ASPEED_VUART_GCRB);
 124         reg &= ASPEED_VUART_GCRB_HOST_SIRQ_MASK;
 125         reg >>= ASPEED_VUART_GCRB_HOST_SIRQ_SHIFT;
 126
 127         return sysfs_emit(buf, "%u\n", reg);
 128 }
 129
 130 static int aspeed_vuart_set_sirq(struct aspeed_vuart *vuart, u32 sirq)
 131 {
 132         u8 reg;
 133
 134         if (sirq > (ASPEED_VUART_GCRB_HOST_SIRQ_MASK >> ASPEED_VUART_GCRB_HOST_SIRQ_SHIFT))
 135                 return -EINVAL;
 136
 137         sirq <<= ASPEED_VUART_GCRB_HOST_SIRQ_SHIFT;
 138         sirq &= ASPEED_VUART_GCRB_HOST_SIRQ_MASK;
 139
 140         reg = aspeed_vuart_readb(vuart, ASPEED_VUART_GCRB);
 141         reg &= ~ASPEED_VUART_GCRB_HOST_SIRQ_MASK;
 142         reg |= sirq;
 143         aspeed_vuart_writeb(vuart, reg, ASPEED_VUART_GCRB);
 144
 145         return 0;
 146 }
 147
 148 static ssize_t sirq_store(struct device *dev, struct device_attribute *attr,
 149                           const char *buf, size_t count)
 150 {
 151         struct aspeed_vuart *vuart = dev_get_drvdata(dev);
 152         unsigned long val;
 153         int err;
 154
 155         err = kstrtoul(buf, 0, &val);
 156         if (err)
 157                 return err;
 158
 159         err = aspeed_vuart_set_sirq(vuart, val);
 160         return err ? : count;
 161 }
 162
 163 static DEVICE_ATTR_RW(sirq);
 164
 165 static ssize_t sirq_polarity_show(struct device *dev,
 166                                   struct device_attribute *attr, char *buf)
 167 {
 168         struct aspeed_vuart *vuart = dev_get_drvdata(dev);
 169         u8 reg;
 170
 171         reg = aspeed_vuart_readb(vuart, ASPEED_VUART_GCRA);
 172         reg &= ASPEED_VUART_GCRA_HOST_SIRQ_POLARITY;
 173
 174         return sysfs_emit(buf, "%u\n", reg ? 1 : 0);
 175 }
 176
 177 static void aspeed_vuart_set_sirq_polarity(struct aspeed_vuart *vuart,
 178                                            bool polarity)
 179 {
 180         u8 reg = aspeed_vuart_readb(vuart, ASPEED_VUART_GCRA);
 181
 182         if (polarity)
 183                 reg |= ASPEED_VUART_GCRA_HOST_SIRQ_POLARITY;
 184         else
 185                 reg &= ~ASPEED_VUART_GCRA_HOST_SIRQ_POLARITY;
 186
 187         aspeed_vuart_writeb(vuart, reg, ASPEED_VUART_GCRA);
 188 }
 189
 190 static ssize_t sirq_polarity_store(struct device *dev,
 191                                    struct device_attribute *attr,
 192                                    const char *buf, size_t count)
 193 {
 194         struct aspeed_vuart *vuart = dev_get_drvdata(dev);
 195         unsigned long val;
 196         int err;
 197
 198         err = kstrtoul(buf, 0, &val);
 199         if (err)
 200                 return err;
 201
 202         aspeed_vuart_set_sirq_polarity(vuart, val != 0);
 203
 204         return count;
 205 }
 206
 207 static DEVICE_ATTR_RW(sirq_polarity);
 208
 209 static struct attribute *aspeed_vuart_attrs[] = {
 210         &dev_attr_sirq.attr,
 211         &dev_attr_sirq_polarity.attr,
 212         &dev_attr_lpc_address.attr,
 213         NULL,
 214 };
 215
 216 static const struct attribute_group aspeed_vuart_attr_group = {
 217         .attrs = aspeed_vuart_attrs,
 218 };
 219
 220 static void aspeed_vuart_set_enabled(struct aspeed_vuart *vuart, bool enabled)
 221 {
 222         u8 reg = aspeed_vuart_readb(vuart, ASPEED_VUART_GCRA);
 223
 224         if (enabled)
 225                 reg |= ASPEED_VUART_GCRA_VUART_EN;
 226         else
 227                 reg &= ~ASPEED_VUART_GCRA_VUART_EN;
 228
 229         aspeed_vuart_writeb(vuart, reg, ASPEED_VUART_GCRA);
 230 }
 231
 232 static void aspeed_vuart_set_host_tx_discard(struct aspeed_vuart *vuart,
 233                                              bool discard)
 234 {
 235         u8 reg;
 236
 237         reg = aspeed_vuart_readb(vuart, ASPEED_VUART_GCRA);
 238
 239         /* If the DISABLE_HOST_TX_DISCARD bit is set, discard is disabled */
 240         if (!discard)
 241                 reg |= ASPEED_VUART_GCRA_DISABLE_HOST_TX_DISCARD;
 242         else
 243                 reg &= ~ASPEED_VUART_GCRA_DISABLE_HOST_TX_DISCARD;
 244
 245         aspeed_vuart_writeb(vuart, reg, ASPEED_VUART_GCRA);
 246 }
 247
 248 static int aspeed_vuart_startup(struct uart_port *uart_port)
 249 {
 250         struct uart_8250_port *uart_8250_port = up_to_u8250p(uart_port);
 251         struct aspeed_vuart *vuart = uart_8250_port->port.private_data;
 252         int rc;
 253
 254         rc = serial8250_do_startup(uart_port);
 255         if (rc)
 256                 return rc;
 257
 258         aspeed_vuart_set_host_tx_discard(vuart, false);
 259
 260         return 0;
 261 }
 262
 263 static void aspeed_vuart_shutdown(struct uart_port *uart_port)
 264 {
 265         struct uart_8250_port *uart_8250_port = up_to_u8250p(uart_port);
 266         struct aspeed_vuart *vuart = uart_8250_port->port.private_data;
 267
 268         aspeed_vuart_set_host_tx_discard(vuart, true);
 269
 270         serial8250_do_shutdown(uart_port);
 271 }
 272
 273 static void __aspeed_vuart_set_throttle(struct uart_8250_port *up,
 274                 bool throttle)
 275 {
 276         unsigned char irqs = UART_IER_RLSI | UART_IER_RDI;
 277
 278         /* Port locked to synchronize UART_IER access against the console. */
 279         lockdep_assert_held_once(&up->port.lock);
 280
 281         up->ier &= ~irqs;
 282         if (!throttle)
 283                 up->ier |= irqs;
 284         serial_out(up, UART_IER, up->ier);
 285 }
 286 static void aspeed_vuart_set_throttle(struct uart_port *port, bool throttle)
 287 {
 288         struct uart_8250_port *up = up_to_u8250p(port);
 289         unsigned long flags;
 290
 291         spin_lock_irqsave(&port->lock, flags);
 292         __aspeed_vuart_set_throttle(up, throttle);
 293         spin_unlock_irqrestore(&port->lock, flags);
 294 }
 295
 296 static void aspeed_vuart_throttle(struct uart_port *port)
 297 {
 298         aspeed_vuart_set_throttle(port, true);
 299 }
 300
 301 static void aspeed_vuart_unthrottle(struct uart_port *port)
 302 {
 303         aspeed_vuart_set_throttle(port, false);
 304 }
 305
 306 static void aspeed_vuart_unthrottle_exp(struct timer_list *timer)
 307 {
 308         struct aspeed_vuart *vuart = from_timer(vuart, timer, unthrottle_timer);
 309         struct uart_8250_port *up = vuart->port;
 310
 311         if (!tty_buffer_space_avail(&up->port.state->port)) {
 312                 mod_timer(&vuart->unthrottle_timer,
 313                           jiffies + unthrottle_timeout);
 314                 return;
 315         }
 316
 317         aspeed_vuart_unthrottle(&up->port);
 318 }
 319
 320 /*
 321  * Custom interrupt handler to manage finer-grained flow control. Although we
 322  * have throttle/unthrottle callbacks, we've seen that the VUART device can
 323  * deliver characters faster than the ldisc has a chance to check buffer space
 324  * against the throttle threshold. This results in dropped characters before
 325  * the throttle.
 326  *
 327  * We do this by checking for flip buffer space before RX. If we have no space,
 328  * throttle now and schedule an unthrottle for later, once the ldisc has had
 329  * a chance to drain the buffers.
 330  */
 331 static int aspeed_vuart_handle_irq(struct uart_port *port)
 332 {
 333         struct uart_8250_port *up = up_to_u8250p(port);
 334         unsigned int iir, lsr;
 335         unsigned long flags;
 336         unsigned int space, count;
 337
 338         iir = serial_port_in(port, UART_IIR);
 339
 340         if (iir & UART_IIR_NO_INT)
 341                 return 0;
 342
 343         spin_lock_irqsave(&port->lock, flags);
 344
 345         lsr = serial_port_in(port, UART_LSR);
 346
 347         if (lsr & (UART_LSR_DR | UART_LSR_BI)) {
 348                 space = tty_buffer_space_avail(&port->state->port);
 349
 350                 if (!space) {
 351                         /* throttle and schedule an unthrottle later */
 352                         struct aspeed_vuart *vuart = port->private_data;
 353                         __aspeed_vuart_set_throttle(up, true);
 354
 355                         if (!timer_pending(&vuart->unthrottle_timer))
 356                                 mod_timer(&vuart->unthrottle_timer,
 357                                           jiffies + unthrottle_timeout);
 358
 359                 } else {
 360                         count = min(space, 256U);
 361
 362                         do {
 363                                 serial8250_read_char(up, lsr);
 364                                 lsr = serial_in(up, UART_LSR);
 365                                 if (--count == 0)
 366                                         break;
 367                         } while (lsr & (UART_LSR_DR | UART_LSR_BI));
 368
 369                         tty_flip_buffer_push(&port->state->port);
 370                 }
 371         }
 372
 373         serial8250_modem_status(up);
 374         if (lsr & UART_LSR_THRE)
 375                 serial8250_tx_chars(up);
 376
 377         uart_unlock_and_check_sysrq_irqrestore(port, flags);
 378
 379         return 1;
 380 }
 381
 382 static void aspeed_vuart_auto_configure_sirq_polarity(
 383         struct aspeed_vuart *vuart, struct device_node *syscon_np,
 384         u32 reg_offset, u32 reg_mask)
 385 {
 386         struct regmap *regmap;
 387         u32 value;
 388
 389         regmap = syscon_node_to_regmap(syscon_np);
 390         if (IS_ERR(regmap)) {
 391                 dev_warn(vuart->dev,
 392                          "could not get regmap for aspeed,sirq-polarity-sense\n");
 393                 return;
 394         }
 395         if (regmap_read(regmap, reg_offset, &value)) {
 396                 dev_warn(vuart->dev, "could not read hw strap table\n");
 397                 return;
 398         }
 399
 400         aspeed_vuart_set_sirq_polarity(vuart, (value & reg_mask) == 0);
 401 }
 402
 403 static int aspeed_vuart_map_irq_polarity(u32 dt)
 404 {
 405         switch (dt) {
 406         case IRQ_TYPE_LEVEL_LOW:
 407                 return 0;
 408         case IRQ_TYPE_LEVEL_HIGH:
 409                 return 1;
 410         default:
 411                 return -EINVAL;
 412         }
 413 }
 414
 415 static int aspeed_vuart_probe(struct platform_device *pdev)
 416 {
 417         struct of_phandle_args sirq_polarity_sense_args;
 418         struct uart_8250_port port;
 419         struct aspeed_vuart *vuart;
 420         struct device_node *np;
 421         struct resource *res;
 422         u32 clk, prop, sirq[2];
 423         int rc, sirq_polarity;
 424
 425         np = pdev->dev.of_node;
 426
 427         vuart = devm_kzalloc(&pdev->dev, sizeof(*vuart), GFP_KERNEL);
 428         if (!vuart)
 429                 return -ENOMEM;
 430
 431         vuart->dev = &pdev->dev;
 432         timer_setup(&vuart->unthrottle_timer, aspeed_vuart_unthrottle_exp, 0);
 433
 434         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 435         if (!res)
 436                 return -EINVAL;
 437
 438         memset(&port, 0, sizeof(port));
 439         port.port.private_data = vuart;
 440         port.port.mapbase = res->start;
 441         port.port.mapsize = resource_size(res);
 442         port.port.startup = aspeed_vuart_startup;
 443         port.port.shutdown = aspeed_vuart_shutdown;
 444         port.port.throttle = aspeed_vuart_throttle;
 445         port.port.unthrottle = aspeed_vuart_unthrottle;
 446         port.port.status = UPSTAT_SYNC_FIFO;
 447         port.port.dev = &pdev->dev;
 448         port.port.has_sysrq = IS_ENABLED(CONFIG_SERIAL_8250_CONSOLE);
 449         port.bugs |= UART_BUG_TXRACE;
 450
 451         rc = sysfs_create_group(&vuart->dev->kobj, &aspeed_vuart_attr_group);
 452         if (rc < 0)
 453                 return rc;
 454
 455         if (of_property_read_u32(np, "clock-frequency", &clk)) {
 456                 vuart->clk = devm_clk_get(&pdev->dev, NULL);
 457                 if (IS_ERR(vuart->clk)) {
 458                         dev_warn(&pdev->dev,
 459                                 "clk or clock-frequency not defined\n");
 460                         rc = PTR_ERR(vuart->clk);
 461                         goto err_sysfs_remove;
 462                 }
 463
 464                 rc = clk_prepare_enable(vuart->clk);
 465                 if (rc < 0)
 466                         goto err_sysfs_remove;
 467
 468                 clk = clk_get_rate(vuart->clk);
 469         }
 470
 471         /* If current-speed was set, then try not to change it. */
 472         if (of_property_read_u32(np, "current-speed", &prop) == 0)
 473                 port.port.custom_divisor = clk / (16 * prop);
 474
 475         /* Check for shifted address mapping */
 476         if (of_property_read_u32(np, "reg-offset", &prop) == 0)
 477                 port.port.mapbase += prop;
 478
 479         /* Check for registers offset within the devices address range */
 480         if (of_property_read_u32(np, "reg-shift", &prop) == 0)
 481                 port.port.regshift = prop;
 482
 483         /* Check for fifo size */
 484         if (of_property_read_u32(np, "fifo-size", &prop) == 0)
 485                 port.port.fifosize = prop;
 486
 487         /* Check for a fixed line number */
 488         rc = of_alias_get_id(np, "serial");
 489         if (rc >= 0)
 490                 port.port.line = rc;
 491
 492         port.port.irq = irq_of_parse_and_map(np, 0);
 493         port.port.handle_irq = aspeed_vuart_handle_irq;
 494         port.port.iotype = UPIO_MEM;
 495         port.port.type = PORT_ASPEED_VUART;
 496         port.port.uartclk = clk;
 497         port.port.flags = UPF_SHARE_IRQ | UPF_BOOT_AUTOCONF | UPF_IOREMAP
 498                 | UPF_FIXED_PORT | UPF_FIXED_TYPE | UPF_NO_THRE_TEST;
 499
 500         if (of_property_read_bool(np, "no-loopback-test"))
 501                 port.port.flags |= UPF_SKIP_TEST;
 502
 503         if (port.port.fifosize)
 504                 port.capabilities = UART_CAP_FIFO;
 505
 506         if (of_property_read_bool(np, "auto-flow-control"))
 507                 port.capabilities |= UART_CAP_AFE;
 508
 509         rc = serial8250_register_8250_port(&port);
 510         if (rc < 0)
 511                 goto err_clk_disable;
 512
 513         vuart->line = rc;
 514         vuart->port = serial8250_get_port(vuart->line);
 515
 516         rc = of_parse_phandle_with_fixed_args(
 517                 np, "aspeed,sirq-polarity-sense", 2, 0,
 518                 &sirq_polarity_sense_args);
 519         if (rc < 0) {
 520                 dev_dbg(&pdev->dev,
 521                         "aspeed,sirq-polarity-sense property not found\n");
 522         } else {
 523                 aspeed_vuart_auto_configure_sirq_polarity(
 524                         vuart, sirq_polarity_sense_args.np,
 525                         sirq_polarity_sense_args.args[0],
 526                         BIT(sirq_polarity_sense_args.args[1]));
 527                 of_node_put(sirq_polarity_sense_args.np);
 528         }
 529
 530         rc = of_property_read_u32(np, "aspeed,lpc-io-reg", &prop);
 531         if (rc < 0)
 532                 prop = ASPEED_VUART_DEFAULT_LPC_ADDR;
 533
 534         rc = aspeed_vuart_set_lpc_address(vuart, prop);
 535         if (rc < 0) {
 536                 dev_err(&pdev->dev, "invalid value in aspeed,lpc-io-reg property\n");
 537                 goto err_clk_disable;
 538         }
 539
 540         rc = of_property_read_u32_array(np, "aspeed,lpc-interrupts", sirq, 2);
 541         if (rc < 0) {
 542                 sirq[0] = ASPEED_VUART_DEFAULT_SIRQ;
 543                 sirq[1] = ASPEED_VUART_DEFAULT_SIRQ_POLARITY;
 544         }
 545
 546         rc = aspeed_vuart_set_sirq(vuart, sirq[0]);
 547         if (rc < 0) {
 548                 dev_err(&pdev->dev, "invalid sirq number in aspeed,lpc-interrupts property\n");
 549                 goto err_clk_disable;
 550         }
 551
 552         sirq_polarity = aspeed_vuart_map_irq_polarity(sirq[1]);
 553         if (sirq_polarity < 0) {
 554                 dev_err(&pdev->dev, "invalid sirq polarity in aspeed,lpc-interrupts property\n");
 555                 rc = sirq_polarity;
 556                 goto err_clk_disable;
 557         }
 558
 559         aspeed_vuart_set_sirq_polarity(vuart, sirq_polarity);
 560
 561         aspeed_vuart_set_enabled(vuart, true);
 562         aspeed_vuart_set_host_tx_discard(vuart, true);
 563         platform_set_drvdata(pdev, vuart);
 564
 565         return 0;
 566
 567 err_clk_disable:
 568         clk_disable_unprepare(vuart->clk);
 569         irq_dispose_mapping(port.port.irq);
 570 err_sysfs_remove:
 571         sysfs_remove_group(&vuart->dev->kobj, &aspeed_vuart_attr_group);
 572         return rc;
 573 }
 574
 575 static int aspeed_vuart_remove(struct platform_device *pdev)
 576 {
 577         struct aspeed_vuart *vuart = platform_get_drvdata(pdev);
 578
 579         del_timer_sync(&vuart->unthrottle_timer);
 580         aspeed_vuart_set_enabled(vuart, false);
 581         serial8250_unregister_port(vuart->line);
 582         sysfs_remove_group(&vuart->dev->kobj, &aspeed_vuart_attr_group);
 583         clk_disable_unprepare(vuart->clk);
 584
 585         return 0;
 586 }
 587
 588 static const struct of_device_id aspeed_vuart_table[] = {
 589         { .compatible = "aspeed,ast2400-vuart" },
 590         { .compatible = "aspeed,ast2500-vuart" },
 591         { },
 592 };
 593
 594 static struct platform_driver aspeed_vuart_driver = {
 595         .driver = {
 596                 .name = "aspeed-vuart",
 597                 .of_match_table = aspeed_vuart_table,
 598         },
 599         .probe = aspeed_vuart_probe,
 600         .remove = aspeed_vuart_remove,
 601 };
 602
 603 module_platform_driver(aspeed_vuart_driver);
 604
 605 MODULE_AUTHOR("Jeremy Kerr <jk@ozlabs.org>");
 606 MODULE_LICENSE("GPL");
 607 MODULE_DESCRIPTION("Driver for Aspeed VUART device");