]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - drivers/tty/serial/serial_ks8695.c
projects / mirror_ubuntu-bionic-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
serial: ks8695: use __iomem pointers for MMIO
[mirror_ubuntu-bionic-kernel.git] / drivers / tty / serial / serial_ks8695.c
CommitLineData
2c7ee6ab 1/*
2c7ee6ab
AV		 2 * Driver for KS8695 serial ports
3 *
4 * Based on drivers/serial/serial_amba.c, by Kam Lee.
5 *
6 * Copyright 2002-2005 Micrel Inc.
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 */
14#include <linux/module.h>
15#include <linux/tty.h>
ee160a38 16#include <linux/tty_flip.h>
2c7ee6ab
AV		 17#include <linux/ioport.h>
18#include <linux/init.h>
19#include <linux/serial.h>
20#include <linux/console.h>
21#include <linux/sysrq.h>
22#include <linux/device.h>
23
24#include <asm/io.h>
25#include <asm/irq.h>
26#include <asm/mach/irq.h>
27
a09e64fb
RK		 28#include <mach/regs-uart.h>
29#include <mach/regs-irq.h>
2c7ee6ab
AV		 30
31#if defined(CONFIG_SERIAL_KS8695_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
32#define SUPPORT_SYSRQ
33#endif
34
35#include <linux/serial_core.h>
36
37
38#define SERIAL_KS8695_MAJOR 204
39#define SERIAL_KS8695_MINOR 16
40#define SERIAL_KS8695_DEVNAME "ttyAM"
41
42#define SERIAL_KS8695_NR 1
43
44/*
45 * Access macros for the KS8695 UART
46 */
47#define UART_GET_CHAR(p) (__raw_readl((p)->membase + KS8695_URRB) & 0xFF)
48#define UART_PUT_CHAR(p, c) __raw_writel((c), (p)->membase + KS8695_URTH)
49#define UART_GET_FCR(p) __raw_readl((p)->membase + KS8695_URFC)
50#define UART_PUT_FCR(p, c) __raw_writel((c), (p)->membase + KS8695_URFC)
51#define UART_GET_MSR(p) __raw_readl((p)->membase + KS8695_URMS)
52#define UART_GET_LSR(p) __raw_readl((p)->membase + KS8695_URLS)
53#define UART_GET_LCR(p) __raw_readl((p)->membase + KS8695_URLC)
54#define UART_PUT_LCR(p, c) __raw_writel((c), (p)->membase + KS8695_URLC)
55#define UART_GET_MCR(p) __raw_readl((p)->membase + KS8695_URMC)
56#define UART_PUT_MCR(p, c) __raw_writel((c), (p)->membase + KS8695_URMC)
57#define UART_GET_BRDR(p) __raw_readl((p)->membase + KS8695_URBD)
58#define UART_PUT_BRDR(p, c) __raw_writel((c), (p)->membase + KS8695_URBD)
59
60#define KS8695_CLR_TX_INT() __raw_writel(1 << KS8695_IRQ_UART_TX, KS8695_IRQ_VA + KS8695_INTST)
61
62#define UART_DUMMY_LSR_RX 0x100
63#define UART_PORT_SIZE (KS8695_USR - KS8695_URRB + 4)
64
457cd4f5
DH		 65static inline int tx_enabled(struct uart_port *port)
66{
67 return port->unused[0] & 1;
68}
69
70static inline int rx_enabled(struct uart_port *port)
71{
72 return port->unused[0] & 2;
73}
74
75static inline int ms_enabled(struct uart_port *port)
76{
77 return port->unused[0] & 4;
78}
79
80static inline void ms_enable(struct uart_port *port, int enabled)
81{
82 if(enabled)
83 port->unused[0] |= 4;
84 else
85 port->unused[0] &= ~4;
86}
87
88static inline void rx_enable(struct uart_port *port, int enabled)
89{
90 if(enabled)
91 port->unused[0] |= 2;
92 else
93 port->unused[0] &= ~2;
94}
95
96static inline void tx_enable(struct uart_port *port, int enabled)
97{
98 if(enabled)
99 port->unused[0] |= 1;
100 else
101 port->unused[0] &= ~1;
102}
2c7ee6ab
AV		 103
104
105#ifdef SUPPORT_SYSRQ
106static struct console ks8695_console;
107#endif
108
109static void ks8695uart_stop_tx(struct uart_port *port)
110{
111 if (tx_enabled(port)) {
c47a830c
DH		 112 /* use disable_irq_nosync() and not disable_irq() to avoid self
113 * imposed deadlock by not waiting for irq handler to end,
114 * since this ks8695uart_stop_tx() is called from interrupt context.
115 */
116 disable_irq_nosync(KS8695_IRQ_UART_TX);
457cd4f5 117 tx_enable(port, 0);
2c7ee6ab
AV		 118 }
119}
120
121static void ks8695uart_start_tx(struct uart_port *port)
122{
123 if (!tx_enabled(port)) {
124 enable_irq(KS8695_IRQ_UART_TX);
457cd4f5 125 tx_enable(port, 1);
2c7ee6ab
AV		 126 }
127}
128
129static void ks8695uart_stop_rx(struct uart_port *port)
130{
131 if (rx_enabled(port)) {
132 disable_irq(KS8695_IRQ_UART_RX);
457cd4f5 133 rx_enable(port, 0);
2c7ee6ab
AV		 134 }
135}
136
137static void ks8695uart_enable_ms(struct uart_port *port)
138{
457cd4f5
DH		 139 if (!ms_enabled(port)) {
140 enable_irq(KS8695_IRQ_UART_MODEM_STATUS);
141 ms_enable(port,1);
142 }
2c7ee6ab
AV		 143}
144
145static void ks8695uart_disable_ms(struct uart_port *port)
146{
457cd4f5
DH		 147 if (ms_enabled(port)) {
148 disable_irq(KS8695_IRQ_UART_MODEM_STATUS);
149 ms_enable(port,0);
150 }
2c7ee6ab
AV		 151}
152
153static irqreturn_t ks8695uart_rx_chars(int irq, void *dev_id)
154{
155 struct uart_port *port = dev_id;
ebd2c8f6 156 struct tty_struct *tty = port->state->port.tty;
2c7ee6ab
AV		 157 unsigned int status, ch, lsr, flg, max_count = 256;
158
159 status = UART_GET_LSR(port); /* clears pending LSR interrupts */
160 while ((status & URLS_URDR) && max_count--) {
161 ch = UART_GET_CHAR(port);
162 flg = TTY_NORMAL;
163
164 port->icount.rx++;
165
166 /*
167 * Note that the error handling code is
168 * out of the main execution path
169 */
170 lsr = UART_GET_LSR(port) | UART_DUMMY_LSR_RX;
171 if (unlikely(lsr & (URLS_URBI | URLS_URPE | URLS_URFE | URLS_URROE))) {
172 if (lsr & URLS_URBI) {
173 lsr &= ~(URLS_URFE | URLS_URPE);
174 port->icount.brk++;
175 if (uart_handle_break(port))
176 goto ignore_char;
177 }
178 if (lsr & URLS_URPE)
179 port->icount.parity++;
180 if (lsr & URLS_URFE)
181 port->icount.frame++;
182 if (lsr & URLS_URROE)
183 port->icount.overrun++;
184
185 lsr &= port->read_status_mask;
186
187 if (lsr & URLS_URBI)
188 flg = TTY_BREAK;
189 else if (lsr & URLS_URPE)
190 flg = TTY_PARITY;
191 else if (lsr & URLS_URFE)
192 flg = TTY_FRAME;
193 }
194
195 if (uart_handle_sysrq_char(port, ch))
196 goto ignore_char;
197
198 uart_insert_char(port, lsr, URLS_URROE, ch, flg);
199
200ignore_char:
201 status = UART_GET_LSR(port);
202 }
203 tty_flip_buffer_push(tty);
204
205 return IRQ_HANDLED;
206}
207
208
209static irqreturn_t ks8695uart_tx_chars(int irq, void *dev_id)
210{
211 struct uart_port *port = dev_id;
ebd2c8f6 212 struct circ_buf *xmit = &port->state->xmit;
2c7ee6ab
AV		 213 unsigned int count;
214
215 if (port->x_char) {
216 KS8695_CLR_TX_INT();
217 UART_PUT_CHAR(port, port->x_char);
218 port->icount.tx++;
219 port->x_char = 0;
220 return IRQ_HANDLED;
221 }
222
223 if (uart_tx_stopped(port) || uart_circ_empty(xmit)) {
224 ks8695uart_stop_tx(port);
225 return IRQ_HANDLED;
226 }
227
228 count = 16; /* fifo size */
229 while (!uart_circ_empty(xmit) && (count-- > 0)) {
230 KS8695_CLR_TX_INT();
231 UART_PUT_CHAR(port, xmit->buf[xmit->tail]);
232
233 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
234 port->icount.tx++;
235 }
236
237 if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
238 uart_write_wakeup(port);
239
240 if (uart_circ_empty(xmit))
241 ks8695uart_stop_tx(port);
242
243 return IRQ_HANDLED;
244}
245
246static irqreturn_t ks8695uart_modem_status(int irq, void *dev_id)
247{
248 struct uart_port *port = dev_id;
249 unsigned int status;
250
251 /*
252 * clear modem interrupt by reading MSR
253 */
254 status = UART_GET_MSR(port);
255
256 if (status & URMS_URDDCD)
257 uart_handle_dcd_change(port, status & URMS_URDDCD);
258
259 if (status & URMS_URDDST)
260 port->icount.dsr++;
261
262 if (status & URMS_URDCTS)
263 uart_handle_cts_change(port, status & URMS_URDCTS);
264
265 if (status & URMS_URTERI)
266 port->icount.rng++;
267
bdc04e31 268 wake_up_interruptible(&port->state->port.delta_msr_wait);
2c7ee6ab
AV		 269
270 return IRQ_HANDLED;
271}
272
273static unsigned int ks8695uart_tx_empty(struct uart_port *port)
274{
275 return (UART_GET_LSR(port) & URLS_URTE) ? TIOCSER_TEMT : 0;
276}
277
278static unsigned int ks8695uart_get_mctrl(struct uart_port *port)
279{
280 unsigned int result = 0;
281 unsigned int status;
282
283 status = UART_GET_MSR(port);
284 if (status & URMS_URDCD)
285 result |= TIOCM_CAR;
286 if (status & URMS_URDSR)
287 result |= TIOCM_DSR;
288 if (status & URMS_URCTS)
289 result |= TIOCM_CTS;
290 if (status & URMS_URRI)
291 result |= TIOCM_RI;
292
293 return result;
294}
295
296static void ks8695uart_set_mctrl(struct uart_port *port, u_int mctrl)
297{
298 unsigned int mcr;
299
300 mcr = UART_GET_MCR(port);
301 if (mctrl & TIOCM_RTS)
302 mcr |= URMC_URRTS;
303 else
304 mcr &= ~URMC_URRTS;
305
306 if (mctrl & TIOCM_DTR)
307 mcr |= URMC_URDTR;
308 else
309 mcr &= ~URMC_URDTR;
310
311 UART_PUT_MCR(port, mcr);
312}
313
314static void ks8695uart_break_ctl(struct uart_port *port, int break_state)
315{
316 unsigned int lcr;
317
318 lcr = UART_GET_LCR(port);
319
320 if (break_state == -1)
321 lcr |= URLC_URSBC;
322 else
323 lcr &= ~URLC_URSBC;
324
325 UART_PUT_LCR(port, lcr);
326}
327
328static int ks8695uart_startup(struct uart_port *port)
329{
330 int retval;
331
332 set_irq_flags(KS8695_IRQ_UART_TX, IRQF_VALID | IRQF_NOAUTOEN);
457cd4f5
DH		 333 tx_enable(port, 0);
334 rx_enable(port, 1);
335 ms_enable(port, 1);
2c7ee6ab
AV		 336
337 /*
338 * Allocate the IRQ
339 */
9cfb5c05 340 retval = request_irq(KS8695_IRQ_UART_TX, ks8695uart_tx_chars, 0, "UART TX", port);
2c7ee6ab
AV		 341 if (retval)
342 goto err_tx;
343
9cfb5c05 344 retval = request_irq(KS8695_IRQ_UART_RX, ks8695uart_rx_chars, 0, "UART RX", port);
2c7ee6ab
AV		 345 if (retval)
346 goto err_rx;
347
9cfb5c05 348 retval = request_irq(KS8695_IRQ_UART_LINE_STATUS, ks8695uart_rx_chars, 0, "UART LineStatus", port);
2c7ee6ab 349 if (retval)
e45c7a43 350 goto err_ls;
2c7ee6ab 351
9cfb5c05 352 retval = request_irq(KS8695_IRQ_UART_MODEM_STATUS, ks8695uart_modem_status, 0, "UART ModemStatus", port);
2c7ee6ab 353 if (retval)
e45c7a43 354 goto err_ms;
2c7ee6ab
AV		 355
356 return 0;
357
358err_ms:
359 free_irq(KS8695_IRQ_UART_LINE_STATUS, port);
360err_ls:
361 free_irq(KS8695_IRQ_UART_RX, port);
362err_rx:
363 free_irq(KS8695_IRQ_UART_TX, port);
364err_tx:
365 return retval;
366}
367
368static void ks8695uart_shutdown(struct uart_port *port)
369{
370 /*
371 * Free the interrupt
372 */
373 free_irq(KS8695_IRQ_UART_RX, port);
374 free_irq(KS8695_IRQ_UART_TX, port);
375 free_irq(KS8695_IRQ_UART_MODEM_STATUS, port);
376 free_irq(KS8695_IRQ_UART_LINE_STATUS, port);
377
378 /* disable break condition and fifos */
379 UART_PUT_LCR(port, UART_GET_LCR(port) & ~URLC_URSBC);
380 UART_PUT_FCR(port, UART_GET_FCR(port) & ~URFC_URFE);
381}
382
383static void ks8695uart_set_termios(struct uart_port *port, struct ktermios *termios, struct ktermios *old)
384{
385 unsigned int lcr, fcr = 0;
386 unsigned long flags;
387 unsigned int baud, quot;
388
389 /*
390 * Ask the core to calculate the divisor for us.
391 */
392 baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk/16);
393 quot = uart_get_divisor(port, baud);
394
395 switch (termios->c_cflag & CSIZE) {
396 case CS5:
397 lcr = URCL_5;
398 break;
399 case CS6:
400 lcr = URCL_6;
401 break;
402 case CS7:
403 lcr = URCL_7;
404 break;
405 default:
406 lcr = URCL_8;
407 break;
408 }
409
410 /* stop bits */
411 if (termios->c_cflag & CSTOPB)
412 lcr |= URLC_URSB;
413
414 /* parity */
415 if (termios->c_cflag & PARENB) {
416 if (termios->c_cflag & CMSPAR) { /* Mark or Space parity */
417 if (termios->c_cflag & PARODD)
418 lcr |= URPE_MARK;
419 else
420 lcr |= URPE_SPACE;
421 }
422 else if (termios->c_cflag & PARODD)
423 lcr |= URPE_ODD;
424 else
425 lcr |= URPE_EVEN;
426 }
427
428 if (port->fifosize > 1)
429 fcr = URFC_URFRT_8 | URFC_URTFR | URFC_URRFR | URFC_URFE;
430
431 spin_lock_irqsave(&port->lock, flags);
432
433 /*
434 * Update the per-port timeout.
435 */
436 uart_update_timeout(port, termios->c_cflag, baud);
437
438 port->read_status_mask = URLS_URROE;
439 if (termios->c_iflag & INPCK)
440 port->read_status_mask |= (URLS_URFE | URLS_URPE);
441 if (termios->c_iflag & (BRKINT | PARMRK))
442 port->read_status_mask |= URLS_URBI;
443
444 /*
445 * Characters to ignore
446 */
447 port->ignore_status_mask = 0;
448 if (termios->c_iflag & IGNPAR)
449 port->ignore_status_mask |= (URLS_URFE | URLS_URPE);
450 if (termios->c_iflag & IGNBRK) {
451 port->ignore_status_mask |= URLS_URBI;
452 /*
453 * If we're ignoring parity and break indicators,
454 * ignore overruns too (for real raw support).
455 */
456 if (termios->c_iflag & IGNPAR)
457 port->ignore_status_mask |= URLS_URROE;
458 }
459
460 /*
461 * Ignore all characters if CREAD is not set.
462 */
463 if ((termios->c_cflag & CREAD) == 0)
464 port->ignore_status_mask |= UART_DUMMY_LSR_RX;
465
466 /* first, disable everything */
467 if (UART_ENABLE_MS(port, termios->c_cflag))
468 ks8695uart_enable_ms(port);
469 else
470 ks8695uart_disable_ms(port);
471
472 /* Set baud rate */
473 UART_PUT_BRDR(port, quot);
474
475 UART_PUT_LCR(port, lcr);
476 UART_PUT_FCR(port, fcr);
477
478 spin_unlock_irqrestore(&port->lock, flags);
479}
480
481static const char *ks8695uart_type(struct uart_port *port)
482{
483 return port->type == PORT_KS8695 ? "KS8695" : NULL;
484}
485
486/*
487 * Release the memory region(s) being used by 'port'
488 */
489static void ks8695uart_release_port(struct uart_port *port)
490{
491 release_mem_region(port->mapbase, UART_PORT_SIZE);
492}
493
494/*
495 * Request the memory region(s) being used by 'port'
496 */
497static int ks8695uart_request_port(struct uart_port *port)
498{
499 return request_mem_region(port->mapbase, UART_PORT_SIZE,
500 "serial_ks8695") != NULL ? 0 : -EBUSY;
501}
502
503/*
504 * Configure/autoconfigure the port.
505 */
506static void ks8695uart_config_port(struct uart_port *port, int flags)
507{
508 if (flags & UART_CONFIG_TYPE) {
509 port->type = PORT_KS8695;
510 ks8695uart_request_port(port);
511 }
512}
513
514/*
515 * verify the new serial_struct (for TIOCSSERIAL).
516 */
517static int ks8695uart_verify_port(struct uart_port *port, struct serial_struct *ser)
518{
519 int ret = 0;
520
521 if (ser->type != PORT_UNKNOWN && ser->type != PORT_KS8695)
522 ret = -EINVAL;
523 if (ser->irq != port->irq)
524 ret = -EINVAL;
525 if (ser->baud_base < 9600)
526 ret = -EINVAL;
527 return ret;
528}
529
530static struct uart_ops ks8695uart_pops = {
531 .tx_empty = ks8695uart_tx_empty,
532 .set_mctrl = ks8695uart_set_mctrl,
533 .get_mctrl = ks8695uart_get_mctrl,
534 .stop_tx = ks8695uart_stop_tx,
535 .start_tx = ks8695uart_start_tx,
536 .stop_rx = ks8695uart_stop_rx,
537 .enable_ms = ks8695uart_enable_ms,
538 .break_ctl = ks8695uart_break_ctl,
539 .startup = ks8695uart_startup,
540 .shutdown = ks8695uart_shutdown,
541 .set_termios = ks8695uart_set_termios,
542 .type = ks8695uart_type,
543 .release_port = ks8695uart_release_port,
544 .request_port = ks8695uart_request_port,
545 .config_port = ks8695uart_config_port,
546 .verify_port = ks8695uart_verify_port,
547};
548
549static struct uart_port ks8695uart_ports[SERIAL_KS8695_NR] = {
550 {
d19bd836
AB		 551 .membase = KS8695_UART_VA,
552 .mapbase = KS8695_UART_PA,
2c7ee6ab
AV		 553 .iotype = SERIAL_IO_MEM,
554 .irq = KS8695_IRQ_UART_TX,
0a51810a 555 .uartclk = KS8695_CLOCK_RATE * 16,
2c7ee6ab
AV		 556 .fifosize = 16,
557 .ops = &ks8695uart_pops,
558 .flags = ASYNC_BOOT_AUTOCONF,
559 .line = 0,
560 }
561};
562
563#ifdef CONFIG_SERIAL_KS8695_CONSOLE
564static void ks8695_console_putchar(struct uart_port *port, int ch)
565{
566 while (!(UART_GET_LSR(port) & URLS_URTHRE))
567 barrier();
568
569 UART_PUT_CHAR(port, ch);
570}
571
572static void ks8695_console_write(struct console *co, const char *s, u_int count)
573{
574 struct uart_port *port = ks8695uart_ports + co->index;
575
576 uart_console_write(port, s, count, ks8695_console_putchar);
577}
578
579static void __init ks8695_console_get_options(struct uart_port *port, int *baud, int *parity, int *bits)
580{
581 unsigned int lcr;
582
583 lcr = UART_GET_LCR(port);
584
585 switch (lcr & URLC_PARITY) {
586 case URPE_ODD:
587 *parity = 'o';
588 break;
589 case URPE_EVEN:
590 *parity = 'e';
591 break;
592 default:
593 *parity = 'n';
594 }
595
596 switch (lcr & URLC_URCL) {
597 case URCL_5:
598 *bits = 5;
599 break;
600 case URCL_6:
601 *bits = 6;
602 break;
603 case URCL_7:
604 *bits = 7;
605 break;
606 default:
607 *bits = 8;
608 }
609
610 *baud = port->uartclk / (UART_GET_BRDR(port) & 0x0FFF);
611 *baud /= 16;
612 *baud &= 0xFFFFFFF0;
613}
614
615static int __init ks8695_console_setup(struct console *co, char *options)
616{
617 struct uart_port *port;
618 int baud = 115200;
619 int bits = 8;
620 int parity = 'n';
621 int flow = 'n';
622
623 /*
624 * Check whether an invalid uart number has been specified, and
625 * if so, search for the first available port that does have
626 * console support.
627 */
628 port = uart_get_console(ks8695uart_ports, SERIAL_KS8695_NR, co);
629
630 if (options)
631 uart_parse_options(options, &baud, &parity, &bits, &flow);
632 else
633 ks8695_console_get_options(port, &baud, &parity, &bits);
634
635 return uart_set_options(port, co, baud, parity, bits, flow);
636}
637
486cab2b 638static struct uart_driver ks8695_reg;
2c7ee6ab
AV		 639
640static struct console ks8695_console = {
641 .name = SERIAL_KS8695_DEVNAME,
642 .write = ks8695_console_write,
643 .device = uart_console_device,
644 .setup = ks8695_console_setup,
645 .flags = CON_PRINTBUFFER,
646 .index = -1,
647 .data = &ks8695_reg,
648};
649
650static int __init ks8695_console_init(void)
651{
0ad70740 652 add_preferred_console(SERIAL_KS8695_DEVNAME, 0, NULL);
2c7ee6ab
AV		 653 register_console(&ks8695_console);
654 return 0;
655}
656
657console_initcall(ks8695_console_init);
658
659#define KS8695_CONSOLE &ks8695_console
660#else
661#define KS8695_CONSOLE NULL
662#endif
663
664static struct uart_driver ks8695_reg = {
665 .owner = THIS_MODULE,
666 .driver_name = "serial_ks8695",
667 .dev_name = SERIAL_KS8695_DEVNAME,
668 .major = SERIAL_KS8695_MAJOR,
669 .minor = SERIAL_KS8695_MINOR,
670 .nr = SERIAL_KS8695_NR,
671 .cons = KS8695_CONSOLE,
672};
673
674static int __init ks8695uart_init(void)
675{
676 int i, ret;
677
678 printk(KERN_INFO "Serial: Micrel KS8695 UART driver\n");
679
680 ret = uart_register_driver(&ks8695_reg);
681 if (ret)
682 return ret;
683
684 for (i = 0; i < SERIAL_KS8695_NR; i++)
685 uart_add_one_port(&ks8695_reg, &ks8695uart_ports[0]);
686
687 return 0;
688}
689
690static void __exit ks8695uart_exit(void)
691{
692 int i;
693
694 for (i = 0; i < SERIAL_KS8695_NR; i++)
695 uart_remove_one_port(&ks8695_reg, &ks8695uart_ports[0]);
696 uart_unregister_driver(&ks8695_reg);
697}
698
699module_init(ks8695uart_init);
700module_exit(ks8695uart_exit);
701
702MODULE_DESCRIPTION("KS8695 serial port driver");
703MODULE_AUTHOR("Micrel Inc.");
704MODULE_LICENSE("GPL");
ubuntu-bionic-kernel mirror