8250_dw.c 15.8 KB
Newer Older
J
Jamie Iles 已提交
1 2 3 4
/*
 * Synopsys DesignWare 8250 driver.
 *
 * Copyright 2011 Picochip, Jamie Iles.
5
 * Copyright 2013 Intel Corporation
J
Jamie Iles 已提交
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * The Synopsys DesignWare 8250 has an extra feature whereby it detects if the
 * LCR is written whilst busy.  If it is, then a busy detect interrupt is
 * raised, the LCR needs to be rewritten and the uart status register read.
 */
#include <linux/device.h>
#include <linux/io.h>
#include <linux/module.h>
#include <linux/serial_8250.h>
#include <linux/serial_reg.h>
#include <linux/of.h>
#include <linux/of_irq.h>
#include <linux/of_platform.h>
#include <linux/platform_device.h>
#include <linux/slab.h>
26
#include <linux/acpi.h>
27
#include <linux/clk.h>
28
#include <linux/reset.h>
29
#include <linux/pm_runtime.h>
J
Jamie Iles 已提交
30

31 32
#include <asm/byteorder.h>

33 34
#include "8250.h"

35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56
/* Offsets for the DesignWare specific registers */
#define DW_UART_USR	0x1f /* UART Status Register */
#define DW_UART_CPR	0xf4 /* Component Parameter Register */
#define DW_UART_UCV	0xf8 /* UART Component Version */

/* Component Parameter Register bits */
#define DW_UART_CPR_ABP_DATA_WIDTH	(3 << 0)
#define DW_UART_CPR_AFCE_MODE		(1 << 4)
#define DW_UART_CPR_THRE_MODE		(1 << 5)
#define DW_UART_CPR_SIR_MODE		(1 << 6)
#define DW_UART_CPR_SIR_LP_MODE		(1 << 7)
#define DW_UART_CPR_ADDITIONAL_FEATURES	(1 << 8)
#define DW_UART_CPR_FIFO_ACCESS		(1 << 9)
#define DW_UART_CPR_FIFO_STAT		(1 << 10)
#define DW_UART_CPR_SHADOW		(1 << 11)
#define DW_UART_CPR_ENCODED_PARMS	(1 << 12)
#define DW_UART_CPR_DMA_EXTRA		(1 << 13)
#define DW_UART_CPR_FIFO_MODE		(0xff << 16)
/* Helper for fifo size calculation */
#define DW_UART_CPR_FIFO_SIZE(a)	(((a >> 16) & 0xff) * 16)


J
Jamie Iles 已提交
57
struct dw8250_data {
58 59
	u8			usr_reg;
	int			line;
60 61
	int			msr_mask_on;
	int			msr_mask_off;
62
	struct clk		*clk;
63
	struct clk		*pclk;
64
	struct reset_control	*rst;
65
	struct uart_8250_dma	dma;
66 67

	unsigned int		skip_autocfg:1;
68
	unsigned int		uart_16550_compatible:1;
J
Jamie Iles 已提交
69 70
};

71 72 73 74
static inline int dw8250_modify_msr(struct uart_port *p, int offset, int value)
{
	struct dw8250_data *d = p->private_data;

75 76 77 78 79 80
	/* Override any modem control signals if needed */
	if (offset == UART_MSR) {
		value |= d->msr_mask_on;
		value &= ~d->msr_mask_off;
	}

81 82 83
	return value;
}

84 85
static void dw8250_force_idle(struct uart_port *p)
{
86 87 88
	struct uart_8250_port *up = up_to_u8250p(p);

	serial8250_clear_and_reinit_fifos(up);
89 90 91
	(void)p->serial_in(p, UART_RX);
}

92
static void dw8250_check_lcr(struct uart_port *p, int value)
J
Jamie Iles 已提交
93
{
94 95
	void __iomem *offset = p->membase + (UART_LCR << p->regshift);
	int tries = 1000;
96 97

	/* Make sure LCR write wasn't ignored */
98 99 100 101 102 103 104 105 106 107 108 109 110
	while (tries--) {
		unsigned int lcr = p->serial_in(p, UART_LCR);

		if ((value & ~UART_LCR_SPAR) == (lcr & ~UART_LCR_SPAR))
			return;

		dw8250_force_idle(p);

#ifdef CONFIG_64BIT
		__raw_writeq(value & 0xff, offset);
#else
		if (p->iotype == UPIO_MEM32)
			writel(value, offset);
111 112
		else if (p->iotype == UPIO_MEM32BE)
			iowrite32be(value, offset);
113 114 115
		else
			writeb(value, offset);
#endif
116
	}
117 118 119 120 121 122 123 124 125 126 127 128 129 130
	/*
	 * FIXME: this deadlocks if port->lock is already held
	 * dev_err(p->dev, "Couldn't set LCR to %d\n", value);
	 */
}

static void dw8250_serial_out(struct uart_port *p, int offset, int value)
{
	struct dw8250_data *d = p->private_data;

	writeb(value, p->membase + (offset << p->regshift));

	if (offset == UART_LCR && !d->uart_16550_compatible)
		dw8250_check_lcr(p, value);
J
Jamie Iles 已提交
131 132 133 134
}

static unsigned int dw8250_serial_in(struct uart_port *p, int offset)
{
135
	unsigned int value = readb(p->membase + (offset << p->regshift));
J
Jamie Iles 已提交
136

137
	return dw8250_modify_msr(p, offset, value);
J
Jamie Iles 已提交
138 139
}

140 141
#ifdef CONFIG_64BIT
static unsigned int dw8250_serial_inq(struct uart_port *p, int offset)
142
{
143 144 145 146 147
	unsigned int value;

	value = (u8)__raw_readq(p->membase + (offset << p->regshift));

	return dw8250_modify_msr(p, offset, value);
148 149
}

150 151
static void dw8250_serial_outq(struct uart_port *p, int offset, int value)
{
152 153
	struct dw8250_data *d = p->private_data;

154 155 156 157 158
	value &= 0xff;
	__raw_writeq(value, p->membase + (offset << p->regshift));
	/* Read back to ensure register write ordering. */
	__raw_readq(p->membase + (UART_LCR << p->regshift));

159 160
	if (offset == UART_LCR && !d->uart_16550_compatible)
		dw8250_check_lcr(p, value);
161 162 163
}
#endif /* CONFIG_64BIT */

J
Jamie Iles 已提交
164 165
static void dw8250_serial_out32(struct uart_port *p, int offset, int value)
{
166 167
	struct dw8250_data *d = p->private_data;

168
	writel(value, p->membase + (offset << p->regshift));
169

170 171
	if (offset == UART_LCR && !d->uart_16550_compatible)
		dw8250_check_lcr(p, value);
J
Jamie Iles 已提交
172 173 174 175
}

static unsigned int dw8250_serial_in32(struct uart_port *p, int offset)
{
176
	unsigned int value = readl(p->membase + (offset << p->regshift));
J
Jamie Iles 已提交
177

178
	return dw8250_modify_msr(p, offset, value);
J
Jamie Iles 已提交
179 180
}

181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198
static void dw8250_serial_out32be(struct uart_port *p, int offset, int value)
{
	struct dw8250_data *d = p->private_data;

	iowrite32be(value, p->membase + (offset << p->regshift));

	if (offset == UART_LCR && !d->uart_16550_compatible)
		dw8250_check_lcr(p, value);
}

static unsigned int dw8250_serial_in32be(struct uart_port *p, int offset)
{
       unsigned int value = ioread32be(p->membase + (offset << p->regshift));

       return dw8250_modify_msr(p, offset, value);
}


J
Jamie Iles 已提交
199 200 201 202 203
static int dw8250_handle_irq(struct uart_port *p)
{
	struct dw8250_data *d = p->private_data;
	unsigned int iir = p->serial_in(p, UART_IIR);

204
	if (serial8250_handle_irq(p, iir))
J
Jamie Iles 已提交
205
		return 1;
206 207

	if ((iir & UART_IIR_BUSY) == UART_IIR_BUSY) {
208
		/* Clear the USR */
209
		(void)p->serial_in(p, d->usr_reg);
J
Jamie Iles 已提交
210 211 212 213 214 215 216

		return 1;
	}

	return 0;
}

217 218 219 220 221 222 223 224 225 226 227 228
static void
dw8250_do_pm(struct uart_port *port, unsigned int state, unsigned int old)
{
	if (!state)
		pm_runtime_get_sync(port->dev);

	serial8250_do_pm(port, state, old);

	if (state)
		pm_runtime_put_sync_suspend(port->dev);
}

229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246
static void dw8250_set_termios(struct uart_port *p, struct ktermios *termios,
			       struct ktermios *old)
{
	unsigned int baud = tty_termios_baud_rate(termios);
	struct dw8250_data *d = p->private_data;
	unsigned int rate;
	int ret;

	if (IS_ERR(d->clk) || !old)
		goto out;

	clk_disable_unprepare(d->clk);
	rate = clk_round_rate(d->clk, baud * 16);
	ret = clk_set_rate(d->clk, rate);
	clk_prepare_enable(d->clk);

	if (!ret)
		p->uartclk = rate;
247 248 249 250 251

	p->status &= ~UPSTAT_AUTOCTS;
	if (termios->c_cflag & CRTSCTS)
		p->status |= UPSTAT_AUTOCTS;

252 253 254 255
out:
	serial8250_do_set_termios(p, termios, old);
}

256 257 258 259 260 261 262 263 264
/*
 * dw8250_fallback_dma_filter will prevent the UART from getting just any free
 * channel on platforms that have DMA engines, but don't have any channels
 * assigned to the UART.
 *
 * REVISIT: This is a work around for limitation in the DMA Engine API. Once the
 * core problem is fixed, this function is no longer needed.
 */
static bool dw8250_fallback_dma_filter(struct dma_chan *chan, void *param)
265
{
266
	return false;
267 268
}

269 270
static bool dw8250_idma_filter(struct dma_chan *chan, void *param)
{
271
	return param == chan->device->dev->parent;
272 273
}

274
static void dw8250_quirks(struct uart_port *p, struct dw8250_data *data)
275
{
276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293
	if (p->dev->of_node) {
		struct device_node *np = p->dev->of_node;
		int id;

		/* get index of serial line, if found in DT aliases */
		id = of_alias_get_id(np, "serial");
		if (id >= 0)
			p->line = id;
#ifdef CONFIG_64BIT
		if (of_device_is_compatible(np, "cavium,octeon-3860-uart")) {
			p->serial_in = dw8250_serial_inq;
			p->serial_out = dw8250_serial_outq;
			p->flags = UPF_SKIP_TEST | UPF_SHARE_IRQ | UPF_FIXED_TYPE;
			p->type = PORT_OCTEON;
			data->usr_reg = 0x27;
			data->skip_autocfg = true;
		}
#endif
294 295 296 297 298
		if (of_device_is_big_endian(p->dev->of_node)) {
			p->iotype = UPIO_MEM32BE;
			p->serial_in = dw8250_serial_in32be;
			p->serial_out = dw8250_serial_out32be;
		}
299 300 301 302 303
	} else if (has_acpi_companion(p->dev)) {
		p->iotype = UPIO_MEM32;
		p->regshift = 2;
		p->serial_in = dw8250_serial_in32;
		p->set_termios = dw8250_set_termios;
304 305
		/* So far none of there implement the Busy Functionality */
		data->uart_16550_compatible = true;
306
	}
307

308
	/* Platforms with iDMA */
309
	if (platform_get_resource_byname(to_platform_device(p->dev),
310
					 IORESOURCE_MEM, "lpss_priv")) {
311 312 313
		p->set_termios = dw8250_set_termios;
		data->dma.rx_param = p->dev->parent;
		data->dma.tx_param = p->dev->parent;
314 315
		data->dma.fn = dw8250_idma_filter;
	}
316 317
}

318 319 320 321 322 323 324 325 326
static void dw8250_setup_port(struct uart_port *p)
{
	struct uart_8250_port *up = up_to_u8250p(p);
	u32 reg;

	/*
	 * If the Component Version Register returns zero, we know that
	 * ADDITIONAL_FEATURES are not enabled. No need to go any further.
	 */
327 328 329 330
	if (p->iotype == UPIO_MEM32BE)
		reg = ioread32be(p->membase + DW_UART_UCV);
	else
		reg = readl(p->membase + DW_UART_UCV);
331 332 333 334 335 336
	if (!reg)
		return;

	dev_dbg(p->dev, "Designware UART version %c.%c%c\n",
		(reg >> 24) & 0xff, (reg >> 16) & 0xff, (reg >> 8) & 0xff);

337 338 339 340
	if (p->iotype == UPIO_MEM32BE)
		reg = ioread32be(p->membase + DW_UART_CPR);
	else
		reg = readl(p->membase + DW_UART_CPR);
341 342 343 344 345 346 347 348 349 350 351 352 353 354 355
	if (!reg)
		return;

	/* Select the type based on fifo */
	if (reg & DW_UART_CPR_FIFO_MODE) {
		p->type = PORT_16550A;
		p->flags |= UPF_FIXED_TYPE;
		p->fifosize = DW_UART_CPR_FIFO_SIZE(reg);
		up->capabilities = UART_CAP_FIFO;
	}

	if (reg & DW_UART_CPR_AFCE_MODE)
		up->capabilities |= UART_CAP_AFE;
}

B
Bill Pemberton 已提交
356
static int dw8250_probe(struct platform_device *pdev)
J
Jamie Iles 已提交
357
{
358
	struct uart_8250_port uart = {};
J
Jamie Iles 已提交
359
	struct resource *regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
360
	int irq = platform_get_irq(pdev, 0);
361
	struct uart_port *p = &uart.port;
J
Jamie Iles 已提交
362
	struct dw8250_data *data;
363
	int err;
364
	u32 val;
J
Jamie Iles 已提交
365

366 367
	if (!regs) {
		dev_err(&pdev->dev, "no registers defined\n");
J
Jamie Iles 已提交
368 369 370
		return -EINVAL;
	}

371 372 373 374 375 376
	if (irq < 0) {
		if (irq != -EPROBE_DEFER)
			dev_err(&pdev->dev, "cannot get irq\n");
		return irq;
	}

377 378 379 380 381 382
	spin_lock_init(&p->lock);
	p->mapbase	= regs->start;
	p->irq		= irq;
	p->handle_irq	= dw8250_handle_irq;
	p->pm		= dw8250_do_pm;
	p->type		= PORT_8250;
383
	p->flags	= UPF_SHARE_IRQ | UPF_FIXED_PORT;
384 385 386 387 388 389 390
	p->dev		= &pdev->dev;
	p->iotype	= UPIO_MEM;
	p->serial_in	= dw8250_serial_in;
	p->serial_out	= dw8250_serial_out;

	p->membase = devm_ioremap(&pdev->dev, regs->start, resource_size(regs));
	if (!p->membase)
H
Heikki Krogerus 已提交
391 392
		return -ENOMEM;

393 394 395 396
	data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
	if (!data)
		return -ENOMEM;

397
	data->dma.fn = dw8250_fallback_dma_filter;
398
	data->usr_reg = DW_UART_USR;
399
	p->private_data = data;
400

401 402 403
	data->uart_16550_compatible = device_property_read_bool(p->dev,
						"snps,uart-16550-compatible");

404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438
	err = device_property_read_u32(p->dev, "reg-shift", &val);
	if (!err)
		p->regshift = val;

	err = device_property_read_u32(p->dev, "reg-io-width", &val);
	if (!err && val == 4) {
		p->iotype = UPIO_MEM32;
		p->serial_in = dw8250_serial_in32;
		p->serial_out = dw8250_serial_out32;
	}

	if (device_property_read_bool(p->dev, "dcd-override")) {
		/* Always report DCD as active */
		data->msr_mask_on |= UART_MSR_DCD;
		data->msr_mask_off |= UART_MSR_DDCD;
	}

	if (device_property_read_bool(p->dev, "dsr-override")) {
		/* Always report DSR as active */
		data->msr_mask_on |= UART_MSR_DSR;
		data->msr_mask_off |= UART_MSR_DDSR;
	}

	if (device_property_read_bool(p->dev, "cts-override")) {
		/* Always report CTS as active */
		data->msr_mask_on |= UART_MSR_CTS;
		data->msr_mask_off |= UART_MSR_DCTS;
	}

	if (device_property_read_bool(p->dev, "ri-override")) {
		/* Always report Ring indicator as inactive */
		data->msr_mask_off |= UART_MSR_RI;
		data->msr_mask_off |= UART_MSR_TERI;
	}

439
	/* Always ask for fixed clock rate from a property. */
440
	device_property_read_u32(p->dev, "clock-frequency", &p->uartclk);
441 442

	/* If there is separate baudclk, get the rate from it. */
443
	data->clk = devm_clk_get(&pdev->dev, "baudclk");
444
	if (IS_ERR(data->clk) && PTR_ERR(data->clk) != -EPROBE_DEFER)
445
		data->clk = devm_clk_get(&pdev->dev, NULL);
446 447
	if (IS_ERR(data->clk) && PTR_ERR(data->clk) == -EPROBE_DEFER)
		return -EPROBE_DEFER;
448
	if (!IS_ERR_OR_NULL(data->clk)) {
449 450 451 452 453
		err = clk_prepare_enable(data->clk);
		if (err)
			dev_warn(&pdev->dev, "could not enable optional baudclk: %d\n",
				 err);
		else
454
			p->uartclk = clk_get_rate(data->clk);
455 456
	}

457
	/* If no clock rate is defined, fail. */
458
	if (!p->uartclk) {
459 460 461 462
		dev_err(&pdev->dev, "clock rate not defined\n");
		return -EINVAL;
	}

463
	data->pclk = devm_clk_get(&pdev->dev, "apb_pclk");
464 465 466 467
	if (IS_ERR(data->clk) && PTR_ERR(data->clk) == -EPROBE_DEFER) {
		err = -EPROBE_DEFER;
		goto err_clk;
	}
468 469 470 471
	if (!IS_ERR(data->pclk)) {
		err = clk_prepare_enable(data->pclk);
		if (err) {
			dev_err(&pdev->dev, "could not enable apb_pclk\n");
472
			goto err_clk;
473
		}
474 475
	}

476
	data->rst = devm_reset_control_get_optional(&pdev->dev, NULL);
477 478 479 480
	if (IS_ERR(data->rst) && PTR_ERR(data->rst) == -EPROBE_DEFER) {
		err = -EPROBE_DEFER;
		goto err_pclk;
	}
481 482 483
	if (!IS_ERR(data->rst))
		reset_control_deassert(data->rst);

484
	dw8250_quirks(p, data);
J
Jamie Iles 已提交
485

486
	/* If the Busy Functionality is not implemented, don't handle it */
487
	if (data->uart_16550_compatible)
488 489
		p->handle_irq = NULL;

490
	if (!data->skip_autocfg)
491
		dw8250_setup_port(p);
492

493 494 495 496 497 498 499
	/* If we have a valid fifosize, try hooking up DMA */
	if (p->fifosize) {
		data->dma.rxconf.src_maxburst = p->fifosize / 4;
		data->dma.txconf.dst_maxburst = p->fifosize / 4;
		uart.dma = &data->dma;
	}

500
	data->line = serial8250_register_8250_port(&uart);
501 502 503 504
	if (data->line < 0) {
		err = data->line;
		goto err_reset;
	}
J
Jamie Iles 已提交
505 506 507

	platform_set_drvdata(pdev, data);

508 509 510
	pm_runtime_set_active(&pdev->dev);
	pm_runtime_enable(&pdev->dev);

J
Jamie Iles 已提交
511
	return 0;
512 513 514 515 516 517 518 519 520 521 522 523 524 525

err_reset:
	if (!IS_ERR(data->rst))
		reset_control_assert(data->rst);

err_pclk:
	if (!IS_ERR(data->pclk))
		clk_disable_unprepare(data->pclk);

err_clk:
	if (!IS_ERR(data->clk))
		clk_disable_unprepare(data->clk);

	return err;
J
Jamie Iles 已提交
526 527
}

B
Bill Pemberton 已提交
528
static int dw8250_remove(struct platform_device *pdev)
J
Jamie Iles 已提交
529 530 531
{
	struct dw8250_data *data = platform_get_drvdata(pdev);

532 533
	pm_runtime_get_sync(&pdev->dev);

J
Jamie Iles 已提交
534 535
	serial8250_unregister_port(data->line);

536 537 538
	if (!IS_ERR(data->rst))
		reset_control_assert(data->rst);

539 540 541
	if (!IS_ERR(data->pclk))
		clk_disable_unprepare(data->pclk);

542 543 544
	if (!IS_ERR(data->clk))
		clk_disable_unprepare(data->clk);

545 546 547
	pm_runtime_disable(&pdev->dev);
	pm_runtime_put_noidle(&pdev->dev);

J
Jamie Iles 已提交
548 549 550
	return 0;
}

551
#ifdef CONFIG_PM_SLEEP
552
static int dw8250_suspend(struct device *dev)
553
{
554
	struct dw8250_data *data = dev_get_drvdata(dev);
555 556 557 558 559 560

	serial8250_suspend_port(data->line);

	return 0;
}

561
static int dw8250_resume(struct device *dev)
562
{
563
	struct dw8250_data *data = dev_get_drvdata(dev);
564 565 566 567 568

	serial8250_resume_port(data->line);

	return 0;
}
569
#endif /* CONFIG_PM_SLEEP */
570

571
#ifdef CONFIG_PM
572 573 574 575
static int dw8250_runtime_suspend(struct device *dev)
{
	struct dw8250_data *data = dev_get_drvdata(dev);

576 577
	if (!IS_ERR(data->clk))
		clk_disable_unprepare(data->clk);
578

579 580 581
	if (!IS_ERR(data->pclk))
		clk_disable_unprepare(data->pclk);

582 583 584 585 586 587 588
	return 0;
}

static int dw8250_runtime_resume(struct device *dev)
{
	struct dw8250_data *data = dev_get_drvdata(dev);

589 590 591
	if (!IS_ERR(data->pclk))
		clk_prepare_enable(data->pclk);

592 593
	if (!IS_ERR(data->clk))
		clk_prepare_enable(data->clk);
594 595 596 597 598 599 600 601 602 603

	return 0;
}
#endif

static const struct dev_pm_ops dw8250_pm_ops = {
	SET_SYSTEM_SLEEP_PM_OPS(dw8250_suspend, dw8250_resume)
	SET_RUNTIME_PM_OPS(dw8250_runtime_suspend, dw8250_runtime_resume, NULL)
};

604
static const struct of_device_id dw8250_of_match[] = {
J
Jamie Iles 已提交
605
	{ .compatible = "snps,dw-apb-uart" },
606
	{ .compatible = "cavium,octeon-3860-uart" },
J
Jamie Iles 已提交
607 608
	{ /* Sentinel */ }
};
609
MODULE_DEVICE_TABLE(of, dw8250_of_match);
J
Jamie Iles 已提交
610

611
static const struct acpi_device_id dw8250_acpi_match[] = {
612 613
	{ "INT33C4", 0 },
	{ "INT33C5", 0 },
614 615
	{ "INT3434", 0 },
	{ "INT3435", 0 },
616
	{ "80860F0A", 0 },
617
	{ "8086228A", 0 },
618
	{ "APMC0D08", 0},
619
	{ "AMD0020", 0 },
620 621 622 623
	{ },
};
MODULE_DEVICE_TABLE(acpi, dw8250_acpi_match);

J
Jamie Iles 已提交
624 625 626
static struct platform_driver dw8250_platform_driver = {
	.driver = {
		.name		= "dw-apb-uart",
627
		.pm		= &dw8250_pm_ops,
628
		.of_match_table	= dw8250_of_match,
629
		.acpi_match_table = ACPI_PTR(dw8250_acpi_match),
J
Jamie Iles 已提交
630 631
	},
	.probe			= dw8250_probe,
632
	.remove			= dw8250_remove,
J
Jamie Iles 已提交
633 634
};

635
module_platform_driver(dw8250_platform_driver);
J
Jamie Iles 已提交
636 637 638 639

MODULE_AUTHOR("Jamie Iles");
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Synopsys DesignWare 8250 serial port driver");
640
MODULE_ALIAS("platform:dw-apb-uart");