1 /* stellarisUartDrv.c - Stellaris UART driver */
2 
3 #define DT_DRV_COMPAT ti_stellaris_uart
4 
5 /*
6  * Copyright (c) 2013-2015 Wind River Systems, Inc.
7  *
8  * SPDX-License-Identifier: Apache-2.0
9  */
10 
11 /**
12  * @brief Driver for Stellaris UART
13  *
14  * Driver for Stellaris UART found namely on TI LM3S6965 board. It is similar to
15  * an 16550 in functionality, but is not register-compatible.
16  * It is also register-compatible with the UART found on TI CC2650 SoC,
17  * so it can be used for boards using it, like the TI SensorTag.
18  *
19  * There is only support for poll-mode, so it can only be used with the printk
20  * and STDOUT_CONSOLE APIs.
21  */
22 
23 #include <zephyr/kernel.h>
24 #include <zephyr/arch/cpu.h>
25 #include <zephyr/sys/__assert.h>
26 #include <soc.h>
27 #include <zephyr/init.h>
28 #include <zephyr/drivers/uart.h>
29 #include <zephyr/linker/sections.h>
30 #include <zephyr/irq.h>
31 
32 /* definitions */
33 
34 /* Stellaris UART module */
35 struct _uart {
36 	uint32_t dr;
37 	union {
38 		uint32_t _sr;
39 		uint32_t _cr;
40 	} u1;
41 	uint8_t _res1[0x010];
42 	uint32_t fr;
43 	uint8_t _res2[0x04];
44 	uint32_t ilpr;
45 	uint32_t ibrd;
46 	uint32_t fbrd;
47 	uint32_t lcrh;
48 	uint32_t ctl;
49 	uint32_t ifls;
50 	uint32_t im;
51 	uint32_t ris;
52 	uint32_t mis;
53 	uint32_t icr;
54 	uint8_t _res3[0xf8c];
55 
56 	uint32_t peripd_id4;
57 	uint32_t peripd_id5;
58 	uint32_t peripd_id6;
59 	uint32_t peripd_id7;
60 	uint32_t peripd_id0;
61 	uint32_t peripd_id1;
62 	uint32_t peripd_id2;
63 	uint32_t peripd_id3;
64 
65 	uint32_t p_cell_id0;
66 	uint32_t p_cell_id1;
67 	uint32_t p_cell_id2;
68 	uint32_t p_cell_id3;
69 };
70 
71 struct uart_stellaris_config {
72 	volatile struct _uart *uart;
73 	uint32_t sys_clk_freq;
74 #ifdef CONFIG_UART_INTERRUPT_DRIVEN
75 	uart_irq_config_func_t irq_config_func;
76 #endif
77 };
78 
79 /* Device data structure */
80 struct uart_stellaris_dev_data_t {
81 	uint32_t baud_rate;	/* Baud rate */
82 
83 #ifdef CONFIG_UART_INTERRUPT_DRIVEN
84 	uart_irq_callback_user_data_t cb;	/**< Callback function pointer */
85 	void *cb_data;	/**< Callback function arg */
86 #endif
87 };
88 
89 /* bits */
90 #define UARTFR_BUSY 0x00000008
91 #define UARTFR_RXFE 0x00000010
92 #define UARTFR_TXFF 0x00000020
93 #define UARTFR_RXFF 0x00000040
94 #define UARTFR_TXFE 0x00000080
95 
96 #define UARTLCRH_FEN 0x00000010
97 #define UARTLCRH_WLEN 0x00000060
98 
99 #define UARTCTL_UARTEN 0x00000001
100 #define UARTCTL_LBE 0x00000800
101 #define UARTCTL_TXEN 0x00000100
102 #define UARTCTL_RXEN 0x00000200
103 
104 #define UARTTIM_RXIM 0x00000010
105 #define UARTTIM_TXIM 0x00000020
106 #define UARTTIM_RTIM 0x00000040
107 #define UARTTIM_FEIM 0x00000080
108 #define UARTTIM_PEIM 0x00000100
109 #define UARTTIM_BEIM 0x00000200
110 #define UARTTIM_OEIM 0x00000400
111 
112 #define UARTMIS_RXMIS 0x00000010
113 #define UARTMIS_TXMIS 0x00000020
114 
115 static const struct uart_driver_api uart_stellaris_driver_api;
116 
117 /**
118  * @brief Set the baud rate
119  *
120  * This routine set the given baud rate for the UART.
121  *
122  * @param dev UART device struct
123  * @param baudrate Baud rate
124  * @param sys_clk_freq_hz System clock frequency in Hz
125  */
baudrate_set(const struct device * dev,uint32_t baudrate,uint32_t sys_clk_freq_hz)126 static void baudrate_set(const struct device *dev,
127 			 uint32_t baudrate, uint32_t sys_clk_freq_hz)
128 {
129 	const struct uart_stellaris_config *config = dev->config;
130 	uint32_t brdi, brdf, div, rem;
131 
132 	/* upon reset, the system clock uses the internal OSC @ 12MHz */
133 
134 	div = (baudrate * 16U);
135 	rem = sys_clk_freq_hz % div;
136 
137 	/*
138 	 * floating part of baud rate (LM3S6965 p.433), equivalent to
139 	 * [float part of (SYSCLK / div)] * 64 + 0.5
140 	 */
141 	brdf = ((((rem * 64U) << 1) / div) + 1) >> 1;
142 
143 	/* integer part of baud rate (LM3S6965 p.433) */
144 	brdi = sys_clk_freq_hz / div;
145 
146 	/*
147 	 * those registers are 32-bit, but the reserved bits should be
148 	 * preserved
149 	 */
150 	config->uart->ibrd = (uint16_t)(brdi & 0xffff); /* 16 bits */
151 	config->uart->fbrd = (uint8_t)(brdf & 0x3f);    /* 6 bits */
152 }
153 
154 /**
155  * @brief Enable the UART
156  *
157  * This routine enables the given UART.
158  *
159  * @param dev UART device struct
160  */
enable(const struct device * dev)161 static inline void enable(const struct device *dev)
162 {
163 	const struct uart_stellaris_config *config = dev->config;
164 
165 	config->uart->ctl |= UARTCTL_UARTEN;
166 }
167 
168 /**
169  * @brief Disable the UART
170  *
171  * This routine disables the given UART.
172  *
173  * @param dev UART device struct
174  */
disable(const struct device * dev)175 static inline void disable(const struct device *dev)
176 {
177 	const struct uart_stellaris_config *config = dev->config;
178 
179 	config->uart->ctl &= ~UARTCTL_UARTEN;
180 
181 	/* ensure transmissions are complete */
182 	while (config->uart->fr & UARTFR_BUSY) {
183 	}
184 
185 	/* flush the FIFOs by disabling them */
186 	config->uart->lcrh &= ~UARTLCRH_FEN;
187 }
188 
189 /*
190  * no stick parity
191  * 8-bit frame
192  * FIFOs disabled
193  * one stop bit
194  * parity disabled
195  * send break off
196  */
197 #define LINE_CONTROL_DEFAULTS UARTLCRH_WLEN
198 
199 /**
200  * @brief Set the default UART line controls
201  *
202  * This routine sets the given UART's line controls to their default settings.
203  *
204  * @param dev UART device struct
205  */
line_control_defaults_set(const struct device * dev)206 static inline void line_control_defaults_set(const struct device *dev)
207 {
208 	const struct uart_stellaris_config *config = dev->config;
209 
210 	config->uart->lcrh = LINE_CONTROL_DEFAULTS;
211 }
212 
213 /**
214  * @brief Initialize UART channel
215  *
216  * This routine is called to reset the chip in a quiescent state.
217  * It is assumed that this function is called only once per UART.
218  *
219  * @param dev UART device struct
220  *
221  * @return 0
222  */
uart_stellaris_init(const struct device * dev)223 static int uart_stellaris_init(const struct device *dev)
224 {
225 	struct uart_stellaris_dev_data_t *data = dev->data;
226 	const struct uart_stellaris_config *config = dev->config;
227 	disable(dev);
228 	baudrate_set(dev, data->baud_rate,
229 		     config->sys_clk_freq);
230 	line_control_defaults_set(dev);
231 	enable(dev);
232 
233 #ifdef CONFIG_UART_INTERRUPT_DRIVEN
234 	config->irq_config_func(dev);
235 #endif
236 
237 	return 0;
238 }
239 
240 /**
241  * @brief Get the UART transmit ready status
242  *
243  * This routine returns the given UART's transmit ready status.
244  *
245  * @param dev UART device struct
246  *
247  * @return 0 if ready to transmit, 1 otherwise
248  */
poll_tx_ready(const struct device * dev)249 static int poll_tx_ready(const struct device *dev)
250 {
251 	const struct uart_stellaris_config *config = dev->config;
252 
253 	return (config->uart->fr & UARTFR_TXFE);
254 }
255 
256 /**
257  * @brief Poll the device for input.
258  *
259  * @param dev UART device struct
260  * @param c Pointer to character
261  *
262  * @return 0 if a character arrived, -1 if the input buffer if empty.
263  */
264 
uart_stellaris_poll_in(const struct device * dev,unsigned char * c)265 static int uart_stellaris_poll_in(const struct device *dev, unsigned char *c)
266 {
267 	const struct uart_stellaris_config *config = dev->config;
268 
269 	if (config->uart->fr & UARTFR_RXFE) {
270 		return (-1);
271 	}
272 
273 	/* got a character */
274 	*c = (unsigned char)config->uart->dr;
275 
276 	return 0;
277 }
278 
279 /**
280  * @brief Output a character in polled mode.
281  *
282  * Checks if the transmitter is empty. If empty, a character is written to
283  * the data register.
284  *
285  * @param dev UART device struct
286  * @param c Character to send
287  */
uart_stellaris_poll_out(const struct device * dev,unsigned char c)288 static void uart_stellaris_poll_out(const struct device *dev,
289 					     unsigned char c)
290 {
291 	const struct uart_stellaris_config *config = dev->config;
292 
293 	while (!poll_tx_ready(dev)) {
294 	}
295 
296 	/* send a character */
297 	config->uart->dr = (uint32_t)c;
298 }
299 
300 #if CONFIG_UART_INTERRUPT_DRIVEN
301 
302 /**
303  * @brief Fill FIFO with data
304  *
305  * @param dev UART device struct
306  * @param tx_data Data to transmit
307  * @param len Number of bytes to send
308  *
309  * @return Number of bytes sent
310  */
uart_stellaris_fifo_fill(const struct device * dev,const uint8_t * tx_data,int len)311 static int uart_stellaris_fifo_fill(const struct device *dev,
312 				    const uint8_t *tx_data,
313 				    int len)
314 {
315 	const struct uart_stellaris_config *config = dev->config;
316 	uint8_t num_tx = 0U;
317 
318 	while ((len - num_tx > 0) && ((config->uart->fr & UARTFR_TXFF) == 0U)) {
319 		config->uart->dr = (uint32_t)tx_data[num_tx++];
320 	}
321 
322 	return (int)num_tx;
323 }
324 
325 /**
326  * @brief Read data from FIFO
327  *
328  * @param dev UART device struct
329  * @param rx_data Pointer to data container
330  * @param size Container size
331  *
332  * @return Number of bytes read
333  */
uart_stellaris_fifo_read(const struct device * dev,uint8_t * rx_data,const int size)334 static int uart_stellaris_fifo_read(const struct device *dev,
335 				    uint8_t *rx_data,
336 				    const int size)
337 {
338 	const struct uart_stellaris_config *config = dev->config;
339 	uint8_t num_rx = 0U;
340 
341 	while ((size - num_rx > 0) && ((config->uart->fr & UARTFR_RXFE) == 0U)) {
342 		rx_data[num_rx++] = (uint8_t)config->uart->dr;
343 	}
344 
345 	return num_rx;
346 }
347 
348 /**
349  * @brief Enable TX interrupt
350  *
351  * @param dev UART device struct
352  */
uart_stellaris_irq_tx_enable(const struct device * dev)353 static void uart_stellaris_irq_tx_enable(const struct device *dev)
354 {
355 	static uint8_t first_time =
356 		1U;	   /* used to allow the first transmission */
357 	uint32_t saved_ctl;  /* saved UARTCTL (control) register */
358 	uint32_t saved_ibrd; /* saved UARTIBRD (integer baud rate) register */
359 	uint32_t saved_fbrd; /* saved UARTFBRD (fractional baud rate) register
360 				*/
361 	const struct uart_stellaris_config *config = dev->config;
362 
363 	if (first_time) {
364 		/*
365 		 * The Tx interrupt will not be set when transmission is first
366 		 * enabled.
367 		 * A character has to be transmitted before Tx interrupts will
368 		 * work,
369 		 * so send one via loopback mode.
370 		 */
371 		first_time = 0U;
372 
373 		/* save current control and baud rate settings */
374 		saved_ctl = config->uart->ctl;
375 		saved_ibrd = config->uart->ibrd;
376 		saved_fbrd = config->uart->fbrd;
377 
378 		/* send a character with default settings via loopback */
379 		disable(dev);
380 		config->uart->fbrd = 0U;
381 		config->uart->ibrd = 1U;
382 		config->uart->lcrh = 0U;
383 		config->uart->ctl = (UARTCTL_UARTEN | UARTCTL_TXEN | UARTCTL_LBE);
384 		config->uart->dr = 0U;
385 
386 		while (config->uart->fr & UARTFR_BUSY) {
387 		}
388 
389 		/* restore control and baud rate settings */
390 		disable(dev);
391 		config->uart->ibrd = saved_ibrd;
392 		config->uart->fbrd = saved_fbrd;
393 		line_control_defaults_set(dev);
394 		config->uart->ctl = saved_ctl;
395 	}
396 
397 	config->uart->im |= UARTTIM_TXIM;
398 }
399 
400 /**
401  * @brief Disable TX interrupt in IER
402  *
403  * @param dev UART device struct
404  */
uart_stellaris_irq_tx_disable(const struct device * dev)405 static void uart_stellaris_irq_tx_disable(const struct device *dev)
406 {
407 	const struct uart_stellaris_config *config = dev->config;
408 
409 	config->uart->im &= ~UARTTIM_TXIM;
410 }
411 
412 /**
413  * @brief Check if Tx IRQ has been raised
414  *
415  * @param dev UART device struct
416  *
417  * @return 1 if a Tx IRQ is pending, 0 otherwise
418  */
uart_stellaris_irq_tx_ready(const struct device * dev)419 static int uart_stellaris_irq_tx_ready(const struct device *dev)
420 {
421 	const struct uart_stellaris_config *config = dev->config;
422 
423 	return ((config->uart->mis & UARTMIS_TXMIS) == UARTMIS_TXMIS);
424 }
425 
426 /**
427  * @brief Enable RX interrupt in IER
428  *
429  * @param dev UART device struct
430  */
uart_stellaris_irq_rx_enable(const struct device * dev)431 static void uart_stellaris_irq_rx_enable(const struct device *dev)
432 {
433 	const struct uart_stellaris_config *config = dev->config;
434 
435 	config->uart->im |= UARTTIM_RXIM;
436 }
437 
438 /**
439  * @brief Disable RX interrupt in IER
440  *
441  * @param dev UART device struct
442  */
uart_stellaris_irq_rx_disable(const struct device * dev)443 static void uart_stellaris_irq_rx_disable(const struct device *dev)
444 {
445 	const struct uart_stellaris_config *config = dev->config;
446 
447 	config->uart->im &= ~UARTTIM_RXIM;
448 }
449 
450 /**
451  * @brief Check if Rx IRQ has been raised
452  *
453  * @param dev UART device struct
454  *
455  * @return 1 if an IRQ is ready, 0 otherwise
456  */
uart_stellaris_irq_rx_ready(const struct device * dev)457 static int uart_stellaris_irq_rx_ready(const struct device *dev)
458 {
459 	const struct uart_stellaris_config *config = dev->config;
460 
461 	return ((config->uart->mis & UARTMIS_RXMIS) == UARTMIS_RXMIS);
462 }
463 
464 /**
465  * @brief Enable error interrupts
466  *
467  * @param dev UART device struct
468  */
uart_stellaris_irq_err_enable(const struct device * dev)469 static void uart_stellaris_irq_err_enable(const struct device *dev)
470 {
471 	const struct uart_stellaris_config *config = dev->config;
472 
473 	config->uart->im |= (UARTTIM_RTIM | UARTTIM_FEIM | UARTTIM_PEIM |
474 			     UARTTIM_BEIM | UARTTIM_OEIM);
475 }
476 
477 /**
478  * @brief Disable error interrupts
479  *
480  * @param dev UART device struct
481  */
uart_stellaris_irq_err_disable(const struct device * dev)482 static void uart_stellaris_irq_err_disable(const struct device *dev)
483 {
484 	const struct uart_stellaris_config *config = dev->config;
485 
486 	config->uart->im &= ~(UARTTIM_RTIM | UARTTIM_FEIM | UARTTIM_PEIM |
487 			      UARTTIM_BEIM | UARTTIM_OEIM);
488 }
489 
490 /**
491  * @brief Check if Tx or Rx IRQ is pending
492  *
493  * @param dev UART device struct
494  *
495  * @return 1 if a Tx or Rx IRQ is pending, 0 otherwise
496  */
uart_stellaris_irq_is_pending(const struct device * dev)497 static int uart_stellaris_irq_is_pending(const struct device *dev)
498 {
499 	const struct uart_stellaris_config *config = dev->config;
500 
501 	/* Look only at Tx and Rx data interrupt flags */
502 	return ((config->uart->mis & (UARTMIS_RXMIS | UARTMIS_TXMIS)) ? 1 : 0);
503 }
504 
505 /**
506  * @brief Update IRQ status
507  *
508  * @param dev UART device struct
509  *
510  * @return Always 1
511  */
uart_stellaris_irq_update(const struct device * dev)512 static int uart_stellaris_irq_update(const struct device *dev)
513 {
514 	return 1;
515 }
516 
517 /**
518  * @brief Set the callback function pointer for IRQ.
519  *
520  * @param dev UART device struct
521  * @param cb Callback function pointer.
522  */
uart_stellaris_irq_callback_set(const struct device * dev,uart_irq_callback_user_data_t cb,void * cb_data)523 static void uart_stellaris_irq_callback_set(const struct device *dev,
524 					    uart_irq_callback_user_data_t cb,
525 					    void *cb_data)
526 {
527 	struct uart_stellaris_dev_data_t * const dev_data = dev->data;
528 
529 	dev_data->cb = cb;
530 	dev_data->cb_data = cb_data;
531 }
532 
533 /**
534  * @brief Interrupt service routine.
535  *
536  * This simply calls the callback function, if one exists.
537  *
538  * @param arg Argument to ISR.
539  */
uart_stellaris_isr(const struct device * dev)540 static void uart_stellaris_isr(const struct device *dev)
541 {
542 	struct uart_stellaris_dev_data_t * const dev_data = dev->data;
543 
544 	if (dev_data->cb) {
545 		dev_data->cb(dev, dev_data->cb_data);
546 	}
547 }
548 
549 #endif /* CONFIG_UART_INTERRUPT_DRIVEN */
550 
551 
552 static const struct uart_driver_api uart_stellaris_driver_api = {
553 	.poll_in = uart_stellaris_poll_in,
554 	.poll_out = uart_stellaris_poll_out,
555 
556 #ifdef CONFIG_UART_INTERRUPT_DRIVEN
557 
558 	.fifo_fill = uart_stellaris_fifo_fill,
559 	.fifo_read = uart_stellaris_fifo_read,
560 	.irq_tx_enable = uart_stellaris_irq_tx_enable,
561 	.irq_tx_disable = uart_stellaris_irq_tx_disable,
562 	.irq_tx_ready = uart_stellaris_irq_tx_ready,
563 	.irq_rx_enable = uart_stellaris_irq_rx_enable,
564 	.irq_rx_disable = uart_stellaris_irq_rx_disable,
565 	.irq_rx_ready = uart_stellaris_irq_rx_ready,
566 	.irq_err_enable = uart_stellaris_irq_err_enable,
567 	.irq_err_disable = uart_stellaris_irq_err_disable,
568 	.irq_is_pending = uart_stellaris_irq_is_pending,
569 	.irq_update = uart_stellaris_irq_update,
570 	.irq_callback_set = uart_stellaris_irq_callback_set,
571 
572 #endif
573 };
574 
575 
576 #ifdef CONFIG_UART_STELLARIS_PORT_0
577 
578 #ifdef CONFIG_UART_INTERRUPT_DRIVEN
579 static void irq_config_func_0(const struct device *port);
580 #endif
581 
582 static const struct uart_stellaris_config uart_stellaris_dev_cfg_0 = {
583 	.uart = (volatile struct _uart *)DT_INST_REG_ADDR(0),
584 	.sys_clk_freq = DT_INST_PROP_BY_PHANDLE(0, clocks, clock_frequency),
585 
586 #ifdef CONFIG_UART_INTERRUPT_DRIVEN
587 	.irq_config_func = irq_config_func_0,
588 #endif
589 };
590 
591 static struct uart_stellaris_dev_data_t uart_stellaris_dev_data_0 = {
592 	.baud_rate = DT_INST_PROP(0, current_speed),
593 };
594 
595 DEVICE_DT_INST_DEFINE(0,
596 		    uart_stellaris_init,
597 		    NULL,
598 		    &uart_stellaris_dev_data_0, &uart_stellaris_dev_cfg_0,
599 		    PRE_KERNEL_1, CONFIG_SERIAL_INIT_PRIORITY,
600 		    &uart_stellaris_driver_api);
601 
602 #ifdef CONFIG_UART_INTERRUPT_DRIVEN
irq_config_func_0(const struct device * dev)603 static void irq_config_func_0(const struct device *dev)
604 {
605 	IRQ_CONNECT(DT_INST_IRQN(0),
606 		    DT_INST_IRQ(0, priority),
607 		    uart_stellaris_isr, DEVICE_DT_INST_GET(0),
608 		    0);
609 	irq_enable(DT_INST_IRQN(0));
610 }
611 #endif
612 
613 #endif /* CONFIG_UART_STELLARIS_PORT_0 */
614 
615 #ifdef CONFIG_UART_STELLARIS_PORT_1
616 
617 #ifdef CONFIG_UART_INTERRUPT_DRIVEN
618 static void irq_config_func_1(const struct device *port);
619 #endif
620 
621 static struct uart_stellaris_config uart_stellaris_dev_cfg_1 = {
622 	.uart = (volatile struct _uart *)DT_INST_REG_ADDR(1),
623 	.sys_clk_freq = DT_INST_PROP_BY_PHANDLE(1, clocks, clock_frequency),
624 
625 #ifdef CONFIG_UART_INTERRUPT_DRIVEN
626 	.irq_config_func = irq_config_func_1,
627 #endif
628 };
629 
630 static struct uart_stellaris_dev_data_t uart_stellaris_dev_data_1 = {
631 	.baud_rate = DT_INST_PROP(1, current_speed),
632 };
633 
634 DEVICE_DT_INST_DEFINE(1,
635 		    uart_stellaris_init,
636 		    NULL,
637 		    &uart_stellaris_dev_data_1, &uart_stellaris_dev_cfg_1,
638 		    PRE_KERNEL_1, CONFIG_SERIAL_INIT_PRIORITY,
639 		    &uart_stellaris_driver_api);
640 
641 #ifdef CONFIG_UART_INTERRUPT_DRIVEN
irq_config_func_1(const struct device * dev)642 static void irq_config_func_1(const struct device *dev)
643 {
644 	IRQ_CONNECT(DT_INST_IRQN(1),
645 		    DT_INST_IRQ(1, priority),
646 		    uart_stellaris_isr, DEVICE_DT_INST_GET(1),
647 		    0);
648 	irq_enable(DT_INST_IRQN(1));
649 }
650 #endif
651 
652 #endif /* CONFIG_UART_STELLARIS_PORT_1 */
653 
654 #ifdef CONFIG_UART_STELLARIS_PORT_2
655 
656 #ifdef CONFIG_UART_INTERRUPT_DRIVEN
657 static void irq_config_func_2(const struct device *port);
658 #endif
659 
660 static const struct uart_stellaris_config uart_stellaris_dev_cfg_2 = {
661 	.uart = (volatile struct _uart *)DT_INST_REG_ADDR(2),
662 	.sys_clk_freq = DT_INST_PROP_BY_PHANDLE(2, clocks, clock_frequency),
663 
664 #ifdef CONFIG_UART_INTERRUPT_DRIVEN
665 	.irq_config_func = irq_config_func_2,
666 #endif
667 };
668 
669 static struct uart_stellaris_dev_data_t uart_stellaris_dev_data_2 = {
670 	.baud_rate = DT_INST_PROP(2, current_speed),
671 };
672 
673 DEVICE_DT_INST_DEFINE(2,
674 		    uart_stellaris_init,
675 		    NULL,
676 		    &uart_stellaris_dev_data_2, &uart_stellaris_dev_cfg_2,
677 		    PRE_KERNEL_1, CONFIG_SERIAL_INIT_PRIORITY,
678 		    &uart_stellaris_driver_api);
679 
680 #ifdef CONFIG_UART_INTERRUPT_DRIVEN
irq_config_func_2(const struct device * dev)681 static void irq_config_func_2(const struct device *dev)
682 {
683 	IRQ_CONNECT(DT_INST_IRQN(2),
684 		    DT_INST_IRQ(2, priority),
685 		    uart_stellaris_isr, DEVICE_DT_INST_GET(2),
686 		    0);
687 	irq_enable(DT_INST_IRQN(2));
688 }
689 #endif
690 
691 #endif /* CONFIG_UART_STELLARIS_PORT_2 */
692